--- dmd/src/dmd/linux.mak.old	2010-12-17 19:11:16.000000000 +0100
+++ dmd/src/dmd/linux.mak	2011-12-22 22:33:15.713547884 +0100
@@ -3,9 +3,10 @@
 TK=tk
 ROOT=root
 
-MODEL=-m32
+MODEL?=32
 
-CC=g++ $(MODEL)
+CC?=gcc
+CXX?=g++
 
 #OPT=-g -g3
 #OPT=-O2
@@ -15,10 +16,12 @@
 WARNINGS=-Wno-deprecated -Wstrict-aliasing
 
 #GFLAGS = $(WARNINGS) -D__near= -D__pascal= -fno-exceptions -g -DDEBUG=1 $(COV)
-GFLAGS = $(WARNINGS) -D__near= -D__pascal= -fno-exceptions -O2
-
-CFLAGS = $(GFLAGS) -I$(ROOT) -D__I86__=1 -DMARS=1 -DTARGET_LINUX=1 -D_DH
-MFLAGS = $(GFLAGS) -I$C -I$(TK) -D__I86__=1 -DMARS=1 -DTARGET_LINUX=1 -D_DH
+DMDFLAGS=$(WARNINGS) -D__near= -D__pascal= -fno-exceptions
+ROOTFLAG=$(DMDFLAGS) -I$(ROOT) -D__I86__=1 -DMARS=1 -DTARGET_LINUX=1 -D_DH
+TKFLAG=$(DMDFLAGS) -I$C -I$(TK) -D__I86__=1 -DMARS=1 -DTARGET_LINUX=1 -D_DH
+CFLAGS+=-m$(MODEL)
+CXXFLAGS+=-m$(MODEL)
+LDFLAGS+=-lm -lstdc++ -lpthread
 
 CH= $C/cc.h $C/global.h $C/parser.h $C/oper.h $C/code.h $C/type.h \
 	$C/dt.h $C/cgcv.h $C/el.h $C/iasm.h
@@ -94,7 +97,7 @@
 all: dmd
 
 dmd: $(DMD_OBJS)
-	gcc $(MODEL) -lstdc++ -lpthread $(COV) $(DMD_OBJS) -o dmd
+	$(CC) $(CFLAGS) $(LDFLAGS) $(COV) $(DMD_OBJS) -o dmd
 
 clean:
 	rm -f $(DMD_OBJS) dmd optab.o id.o impcnvgen idgen id.c id.h \
@@ -105,7 +108,7 @@
 ######## optabgen generates some source
 
 optabgen: $C/optabgen.c $C/cc.h $C/oper.h
-	$(CC) $(MFLAGS) $< -o optabgen
+	$(CXX) $(CXXFLAGS) $(TKFLAG) $< -o optabgen
 	./optabgen
 
 optabgen_output = debtab.c optab.c cdxxx.c elxxx.c fltables.c tytab.c
@@ -117,7 +120,7 @@
 $(idgen_output) : idgen
 
 idgen : idgen.c
-	$(CC) idgen.c -o idgen
+	$(CXX) $(CXXFLAGS) idgen.c -o idgen
 	./idgen
 
 ######### impcnvgen generates some source
@@ -126,7 +129,7 @@
 $(impcnvtab_output) : impcnvgen
 
 impcnvgen : mtype.h impcnvgen.c
-	$(CC) $(CFLAGS) impcnvgen.c -o impcnvgen
+	$(CXX) $(CXXFLAGS) $(ROOTFLAG) impcnvgen.c -o impcnvgen
 	./impcnvgen
 
 #########
@@ -134,397 +137,397 @@
 $(DMD_OBJS) : $(idgen_output) $(optabgen_output) $(impcnvgen_output)
 
 aa.o: $C/aa.h $C/tinfo.h $C/aa.c
-	$(CC) -c $(MFLAGS) -I. $C/aa.c
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) -I. $C/aa.c
 
 aav.o: $(ROOT)/aav.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 access.o: access.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 aliasthis.o: aliasthis.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 argtypes.o: argtypes.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 array.o: $(ROOT)/array.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 arrayop.o: arrayop.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 async.o: $(ROOT)/async.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 attrib.o: attrib.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 bcomplex.o: $C/bcomplex.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 bit.o: expression.h bit.c
-	$(CC) -c -I$(ROOT) $(MFLAGS) bit.c
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $(TKFLAG) bit.c
 
 blockopt.o: $C/blockopt.c
-	$(CC) -c $(MFLAGS) $C/blockopt.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/blockopt.c
 
 builtin.o: builtin.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 cast.o: cast.c
-	$(CC) -c $(CFLAGS) $< 
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $< 
 
 cg.o: fltables.c $C/cg.c
-	$(CC) -c $(MFLAGS) -I. $C/cg.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I. $C/cg.c
 
 cg87.o: $C/cg87.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 cgcod.o: $C/cgcod.c
-	$(CC) -c $(MFLAGS) -I. $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I. $<
 
 cgcs.o: $C/cgcs.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 cgcv.o: $C/cgcv.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 cgelem.o: $C/rtlsym.h $C/cgelem.c
-	$(CC) -c $(MFLAGS) -I. $C/cgelem.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I. $C/cgelem.c
 
 cgen.o: $C/rtlsym.h $C/cgen.c
-	$(CC) -c $(MFLAGS) $C/cgen.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/cgen.c
 
 cgobj.o: $C/cgobj.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 cgreg.o: $C/cgreg.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 cgsched.o: $C/rtlsym.h $C/cgsched.c
-	$(CC) -c $(MFLAGS) $C/cgsched.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/cgsched.c
 
 class.o: class.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 clone.o: clone.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 cod1.o: $C/rtlsym.h $C/cod1.c
-	$(CC) -c $(MFLAGS) $C/cod1.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/cod1.c
 
 cod2.o: $C/rtlsym.h $C/cod2.c
-	$(CC) -c $(MFLAGS) $C/cod2.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/cod2.c
 
 cod3.o: $C/rtlsym.h $C/cod3.c
-	$(CC) -c $(MFLAGS) $C/cod3.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/cod3.c
 
 cod4.o: $C/cod4.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 cod5.o: $C/cod5.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 code.o: $C/code.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 constfold.o: constfold.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 irstate.o: irstate.h irstate.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) irstate.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) irstate.c
 
 csymbol.o : $C/symbol.c
-	$(CC) -c $(MFLAGS) $C/symbol.c -o csymbol.o
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/symbol.c -o csymbol.o
 
 dchar.o: $(ROOT)/dchar.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 cond.o: cond.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 cppmangle.o: cppmangle.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 debug.o: $C/debug.c
-	$(CC) -c $(MFLAGS) -I. $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I. $<
 
 declaration.o: declaration.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 delegatize.o: delegatize.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 doc.o: doc.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 dsymbol.o: dsymbol.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 dt.o: $C/dt.h $C/dt.c
-	$(CC) -c $(MFLAGS) $C/dt.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/dt.c
 
 dump.o: dump.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 dwarf.o: $C/dwarf.h $C/dwarf.c
-	$(CC) -c $(MFLAGS) -I. $C/dwarf.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I. $C/dwarf.c
 
 e2ir.o: $C/rtlsym.h expression.h toir.h e2ir.c
-	$(CC) -c -I$(ROOT) $(MFLAGS) e2ir.c
+	$(CXX) -c -I$(ROOT) $(CXXFLAGS) $(TKFLAG) e2ir.c
 
 ee.o: $C/ee.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 eh.o : $C/cc.h $C/code.h $C/type.h $C/dt.h eh.c
-	$(CC) -c $(MFLAGS) eh.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) eh.c
 
 el.o: $C/rtlsym.h $C/el.h $C/el.c
-	$(CC) -c $(MFLAGS) $C/el.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/el.c
 
 elfobj.o: $C/elfobj.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 entity.o: entity.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 enum.o: enum.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 evalu8.o: $C/evalu8.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 expression.o: expression.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 func.o: func.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 gdag.o: $C/gdag.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 gflow.o: $C/gflow.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 #globals.o: globals.c
-#	$(CC) -c $(CFLAGS) $<
+#	$(CXX) -c $(CXXFLAGS) $<
 
 glocal.o: $C/rtlsym.h $C/glocal.c
-	$(CC) -c $(MFLAGS) $C/glocal.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/glocal.c
 
 gloop.o: $C/gloop.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 glue.o: $(CH) $(TOTALH) $C/rtlsym.h mars.h module.h glue.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) glue.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) glue.c
 
 gnuc.o: $(ROOT)/gnuc.h $(ROOT)/gnuc.c
-	$(CC) -c $(GFLAGS) $(ROOT)/gnuc.c
+	$(CXX) -c $(CXXFLAGS) $(ROOT)/gnuc.c
 
 go.o: $C/go.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 gother.o: $C/gother.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 hdrgen.o: hdrgen.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 html.o: $(CH) $(TOTALH) $C/html.h $C/html.c
-	$(CC) -c -I$(ROOT) $(MFLAGS) $C/html.c
+	$(CXX) -c -I$(ROOT) $(CXXFLAGS) $(TKFLAG) $C/html.c
 
 iasm.o : $(CH) $(TOTALH) $C/iasm.h iasm.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) iasm.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) iasm.c
 
 id.o : id.h id.c
-	$(CC) -c $(CFLAGS) id.c
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) id.c
 
 identifier.o: identifier.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 impcnvtab.o: mtype.h impcnvtab.c
-	$(CC) -c $(CFLAGS) -I$(ROOT) impcnvtab.c
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) -I$(ROOT) impcnvtab.c
 
 imphint.o: imphint.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 import.o: import.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 inifile.o: inifile.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 init.o: init.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 inline.o: inline.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 interpret.o: interpret.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 json.o: json.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 lexer.o: lexer.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 libelf.o: libelf.c $C/melf.h
-	$(CC) -c $(CFLAGS) -I$C $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) -I$C $<
 
 libmach.o: libmach.c $C/mach.h
-	$(CC) -c $(CFLAGS) -I$C $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) -I$C $<
 
 link.o: link.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 lstring.o: $(ROOT)/lstring.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 machobj.o: $C/machobj.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 macro.o: macro.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 man.o: $(ROOT)/man.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 mangle.o: mangle.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 mars.o: mars.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 rmem.o: $(ROOT)/rmem.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $(ROOT)/rmem.c
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $(ROOT)/rmem.c
 	
 module.o: $(TOTALH) $C/html.h module.c
-	$(CC) -c $(CFLAGS) -I$C module.c
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) -I$C module.c
 
 msc.o: $(CH) mars.h msc.c
-	$(CC) -c $(MFLAGS) msc.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) msc.c
 
 mtype.o: mtype.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 nteh.o: $C/rtlsym.h $C/nteh.c
-	$(CC) -c $(MFLAGS) $C/nteh.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/nteh.c
 
 opover.o: opover.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 optimize.o: optimize.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 os.o: $C/os.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 out.o: $C/out.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 outbuf.o : $C/outbuf.h $C/outbuf.c
-	$(CC) -c $(MFLAGS) $C/outbuf.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/outbuf.c
 
 parse.o: parse.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 ph.o: ph.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 port.o: $(ROOT)/port.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 ptrntab.o: $C/iasm.h $C/ptrntab.c
-	$(CC) -c $(MFLAGS) $C/ptrntab.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/ptrntab.c
 
 response.o: $(ROOT)/response.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 root.o: $(ROOT)/root.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 rtlsym.o: $C/rtlsym.h $C/rtlsym.c
-	$(CC) -c $(MFLAGS) $C/rtlsym.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/rtlsym.c
 
 s2ir.o : $C/rtlsym.h statement.h s2ir.c
-	$(CC) -c -I$(ROOT) $(MFLAGS) s2ir.c
+	$(CXX) -c -I$(ROOT) $(CXXFLAGS) $(TKFLAG) s2ir.c
 
 scope.o: scope.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 speller.o: $(ROOT)/speller.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 statement.o: statement.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 staticassert.o: staticassert.h staticassert.c
-	$(CC) -c $(CFLAGS) staticassert.c
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) staticassert.c
 
 stringtable.o: $(ROOT)/stringtable.c
-	$(CC) -c $(GFLAGS) -I$(ROOT) $<
+	$(CXX) -c $(CXXFLAGS) -I$(ROOT) $<
 
 strtold.o: $C/strtold.c
-	gcc $(MODEL) -c $C/strtold.c
+	$(CC) -c $(CFLAGS) $C/strtold.c
 
 struct.o: struct.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 template.o: template.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 ti_achar.o: $C/tinfo.h $C/ti_achar.c
-	$(CC) -c $(MFLAGS) -I. $C/ti_achar.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I. $C/ti_achar.c
 
 tk.o: tk.c
-	$(CC) -c $(MFLAGS) tk.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) tk.c
 
 tocsym.o: $(CH) $(TOTALH) mars.h module.h tocsym.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) tocsym.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) tocsym.c
 
 toctype.o: $(CH) $(TOTALH) $C/rtlsym.h mars.h module.h toctype.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) toctype.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) toctype.c
 
 todt.o : mtype.h expression.h $C/dt.h todt.c
-	$(CC) -c -I$(ROOT) $(MFLAGS) todt.c
+	$(CXX) -c -I$(ROOT) $(CXXFLAGS) $(TKFLAG) todt.c
 
 toelfdebug.o: $(CH) $(TOTALH) mars.h toelfdebug.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) toelfdebug.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) toelfdebug.c
 
 toir.o: $C/rtlsym.h expression.h toir.h toir.c
-	$(CC) -c -I$(ROOT) $(MFLAGS) toir.c
+	$(CXX) -c -I$(ROOT) $(CXXFLAGS) $(TKFLAG) toir.c
 
 toobj.o: $(CH) $(TOTALH) mars.h module.h toobj.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) toobj.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) toobj.c
 
 traits.o: $(TOTALH) traits.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 type.o: $C/type.c
-	$(CC) -c $(MFLAGS) $C/type.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $C/type.c
 
 typinf.o: $(CH) $(TOTALH) mars.h module.h mtype.h typinf.c
-	$(CC) -c $(MFLAGS) -I$(ROOT) typinf.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I$(ROOT) typinf.c
 
 util.o: util.c
-	$(CC) -c $(MFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) $<
 
 utf.o: utf.h utf.c
-	$(CC) -c $(CFLAGS) utf.c
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) utf.c
 
 unialpha.o: unialpha.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 unittests.o: unittests.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 var.o: $C/var.c optab.c
-	$(CC) -c $(MFLAGS) -I. $C/var.c
+	$(CXX) -c $(CXXFLAGS) $(TKFLAG) -I. $C/var.c
 
 version.o: version.c
-	$(CC) -c $(CFLAGS) $<
+	$(CXX) -c $(CXXFLAGS) $(ROOTFLAG) $<
 
 ######################################################
 
--- dmd/src/phobos/linux.mak.old	2010-12-17 19:11:16.000000000 +0100
+++ dmd/src/phobos/linux.mak	2011-12-22 22:33:20.388836783 +0100
@@ -12,15 +12,17 @@
 LIB=libphobos.a
 
 MAKEFILE=linux.mak
-MODEL=32
+MODEL?=32
 
-CFLAGS=-O -m$(MODEL)
+CFLAGS+=-m$(MODEL)
+CXXFLAGS+=-m$(MODEL)
 #CFLAGS=-g -m$(MODEL)
 
 DFLAGS=-O -release -w -m$(MODEL)
 #DFLAGS=-unittest -w -m$(MODEL)
 
-CC=gcc
+CC?=gcc
+CXX?=g++
 #DMD=/dmd/bin/dmd
 DMD=dmd
 
@@ -30,13 +32,13 @@
 	$(CC) -c $(CFLAGS) $*.c
 
 .cpp.o:
-	g++ -c $(CFLAGS) $*.cpp
+	$(CXX) -c $(CXXFLAGS) $*.cpp
 
 .d.o:
 	$(DMD) -c $(DFLAGS) $*.d
 
 .asm.o:
-	$(CC) -c $*.asm
+	$(CC) $(CFLAGS) -c $*.asm
 
 targets : $(LIB)
 
@@ -44,7 +46,7 @@
 	$(DMD) -c test -g
 
 test : test.o $(LIB)
-	$(CC) -o $@ test.o $(LIB) -lpthread -lm -g
+	$(CC) $(CFLAGS) -o $@ test.o $(LIB) -lpthread -lm -g
 
 OBJS = complex.o gcstats.o \
 	critical.o object.o monitor.o \
--- dmd/src/phobos/internal/gc/linux.mak.old	2010-12-17 19:11:16.000000000 +0100
+++ dmd/src/phobos/internal/gc/linux.mak	2011-12-22 23:59:59.328158400 +0100
@@ -1,14 +1,14 @@
 
 # makefile to build linux D garbage collector
 
-MODEL=32
+MODEL?=32
 #DMD=../../../dmd
 DMD=dmd
-CFLAGS=-g -m$(MODEL)
+CFLAGS+=-g -m$(MODEL)
 #DFLAGS=-unittest -g -release
 DFLAGS=-release -O -inline -m$(MODEL) -I../..
 #DFLAGS=-release -inline -O
-CC=gcc
+CC?=gcc
 MAKEFILE=linux.mak
 
 OBJS= gc.o gcx.o gcbits.o gclinux.o gcold.o