eliminate rmkdir and generate directory dependencies the right way.
authorRoyce Mitchell III <royce3@ev1.net>
Tue, 22 Mar 2005 07:25:53 +0000 (07:25 +0000)
committerRoyce Mitchell III <royce3@ev1.net>
Tue, 22 Mar 2005 07:25:53 +0000 (07:25 +0000)
treat ROS_TEMPORARY, ROS_INTERMEDIATE, and ROS_OUTPUT as potential different directories.
major refactor of mingw backend to simplify things, and fix some output bugs, as well as reduce makefile.auto size a bit.
create all macros before we start writing rules ( create all target macros before any other ), this fixes bug with macros being empty because they're used before they're defined

svn path=/branches/xmlbuildsystem/; revision=14265

20 files changed:
reactos/Makefile
reactos/lib/zlib/zlib.mak
reactos/tools/bin2res/bin2res.mak
reactos/tools/buildno/buildno.mak
reactos/tools/cabman/cabman.mak
reactos/tools/cdmake/cdmake.mak
reactos/tools/nci/nci.mak
reactos/tools/rbuild/backend/mingw/mingw.cpp
reactos/tools/rbuild/backend/mingw/mingw.h
reactos/tools/rbuild/backend/mingw/modulehandler.cpp
reactos/tools/rbuild/backend/mingw/modulehandler.h
reactos/tools/rbuild/module.cpp
reactos/tools/rbuild/rbuild.h
reactos/tools/rbuild/rbuild.mak
reactos/tools/tools.mak
reactos/tools/unicode/unicode.mak
reactos/tools/winebuild/winebuild.mak
reactos/tools/wmc/wmc.mak
reactos/tools/wpp/wpp.mak
reactos/tools/wrc/wrc.mak

index c94b1ad..7a68dba 100644 (file)
@@ -100,7 +100,7 @@ ifeq ($(HOST),mingw32-linux)
        EXEPREFIX = ./
        EXEPOSTFIX =
        SEP = /
-       nmkdir = -$(Q)mkdir -p
+       mkdir = -$(Q)mkdir -p
        gcc = $(Q)mingw32-gcc
        gpp = $(Q)mingw32-g++
        ld = $(Q)mingw32-ld
@@ -116,7 +116,7 @@ else # mingw32-windows
        EXEPOSTFIX = .exe
        ROS_EMPTY =
        SEP = \$(ROS_EMPTY)
-       nmkdir = -$(Q)mkdir
+       mkdir = -$(Q)mkdir
        gcc = $(Q)gcc
        gpp = $(Q)g++
        ld = $(Q)ld
@@ -130,28 +130,26 @@ else # mingw32-windows
 endif
 
 ifneq ($(ROS_INTERMEDIATE),)
-  INTERMEDIATE = .$(SEP)$(ROS_INTERMEDIATE)$(SEP)
-  INTERMEDIATE_NO_SLASH := $(ROS_INTERMEDIATE)
+  INTERMEDIATE := $(ROS_INTERMEDIATE)
 else
-  INTERMEDIATE = obj-i386$(SEP)
-  INTERMEDIATE_NO_SLASH = obj-i386
+  INTERMEDIATE := obj-i386
 endif
+INTERMEDIATE_ := $(INTERMEDIATE)$(SEP)
 
 ifneq ($(ROS_OUTPUT),)
-  OUTPUT = $(ROS_OUTPUT)$(SEP)
-  OUTPUT_NO_SLASH = $(ROS_OUTPUT)
+  OUTPUT := $(ROS_OUTPUT)
 else
-  OUTPUT = obj-i386$(SEP)
-  OUTPUT_NO_SLASH = obj-i386
+  OUTPUT := obj-i386
 endif
+OUTPUT_ := $(OUTPUT)$(SEP)
 
-mkdir = -$(Q)$(INTERMEDIATE)rmkdir
-EXISTS = .exists
-INTERMEDIATE_EXISTS = $(INTERMEDIATE)$(EXISTS)
+$(INTERMEDIATE):
+       ${mkdir} $@
 
-$(INTERMEDIATE_EXISTS):
-       -${nmkdir} $(INTERMEDIATE_NO_SLASH) 2>$(NUL) >$(NUL)
-       @echo . > $@
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(OUTPUT):
+       ${mkdir} $@
+endif
 
 NTOSKRNL_MC = ntoskrnl$(SEP)ntoskrnl.mc
 KERNEL32_MC = lib$(SEP)kernel32$(SEP)kernel32.mc
@@ -161,6 +159,7 @@ BUGCODES_RC = ntoskrnl$(SEP)bugcodes.rc
 ERRCODES_H = include$(SEP)reactos$(SEP)errcodes.h
 ERRCODES_RC = lib$(SEP)kernel32$(SEP)errcodes.rc
 
+include lib/lib.mak
 include tools/tools.mak
 -include makefile.auto
 
index 2a0ab11..85ea498 100755 (executable)
@@ -1,29 +1,31 @@
-ZLIB_BASE = lib$(SEP)zlib
+ZLIB_BASE = $(LIB_BASE_)zlib
+ZLIB_BASE_ = $(ZLIB_BASE)$(SEP)
 
-ZLIB_BASE_DIR = $(INTERMEDIATE)$(ZLIB_BASE)
+ZLIB_INT = $(INTERMEDIATE_)$(ZLIB_BASE)
+ZLIB_OUT = $(OUTPUT_)$(ZLIB_BASE)
 
-
-#$(ZLIB_BASE_DIR): $(INTERMEDIATE_NO_SLASH) $(RMKDIR_TARGET)
+#$(ZLIB_INT): $(INTERMEDIATE_NO_SLASH) $(RMKDIR_TARGET)
 #      ${mkdir} $(INTERMEDIATE)$(ZLIB_BASE)
 
 ZLIB_HOST_TARGET = \
-       $(INTERMEDIATE)$(ZLIB_BASE)$(SEP)zlib.host.a
-
-ZLIB_HOST_SOURCES = \
-       $(ZLIB_BASE)$(SEP)adler32.c \
-       $(ZLIB_BASE)$(SEP)compress.c \
-       $(ZLIB_BASE)$(SEP)crc32.c \
-       $(ZLIB_BASE)$(SEP)gzio.c \
-       $(ZLIB_BASE)$(SEP)uncompr.c \
-       $(ZLIB_BASE)$(SEP)deflate.c \
-       $(ZLIB_BASE)$(SEP)trees.c \
-       $(ZLIB_BASE)$(SEP)zutil.c \
-       $(ZLIB_BASE)$(SEP)inflate.c \
-       $(ZLIB_BASE)$(SEP)infblock.c \
-       $(ZLIB_BASE)$(SEP)inftrees.c \
-       $(ZLIB_BASE)$(SEP)infcodes.c \
-       $(ZLIB_BASE)$(SEP)infutil.c \
-       $(ZLIB_BASE)$(SEP)inffast.c
+       $(ZLIB_OUT)$(SEP)zlib.host.a
+
+ZLIB_HOST_SOURCES = $(addprefix $(ZLIB_BASE_), \
+       adler32.c \
+       compress.c \
+       crc32.c \
+       gzio.c \
+       uncompr.c \
+       deflate.c \
+       trees.c \
+       zutil.c \
+       inflate.c \
+       infblock.c \
+       inftrees.c \
+       infcodes.c \
+       infutil.c \
+       inffast.c \
+       )
 
 ZLIB_HOST_OBJECTS = \
        $(ZLIB_HOST_SOURCES:.c=.o)
@@ -34,9 +36,9 @@ ZLIB_HOST_CFLAGS = -MMD -O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
 .PHONY: zlib_host
 zlib_host: $(ZLIB_HOST_TARGET)
 
-$(ZLIB_HOST_TARGET): $(ZLIB_HOST_BASE_DIR) $(ZLIB_HOST_OBJECTS)
+$(ZLIB_HOST_TARGET): $(ZLIB_HOST_OBJECTS) $(ZLIB_OUT)
        $(ECHO_AR)
-       $(host_ar) -r $(ZLIB_HOST_TARGET) $(ZLIB_HOST_OBJECTS)
+       $(host_ar) -r $@ $(ZLIB_HOST_OBJECTS)
 
 $(ZLIB_HOST_OBJECTS): %.o : %.c $(ZLIB_BASE_DIR)
        $(ECHO_CC)
index 43aaaff..3424788 100644 (file)
@@ -1,35 +1,44 @@
-BIN2RES_BASE = $(TOOLS_BASE)$(SEP)bin2res
-
-BIN2RES_BASE_DIR = $(INTERMEDIATE)$(BIN2RES_BASE)
-BIN2RES_BASE_DIR_EXISTS = $(BIN2RES_BASE_DIR)$(SEP)$(EXISTS)
-
-$(BIN2RES_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
-       ${mkdir} $(BIN2RES_BASE_DIR)
-       @echo . >$(BIN2RES_BASE_DIR_EXISTS)
+BIN2RES_BASE = $(TOOLS_BASE_)bin2res
+BIN2RES_BASE_ = $(BIN2RES_BASE)$(SEP)
+BIN2RES_INT = $(INTERMEDIATE_)$(BIN2RES_BASE)
+BIN2RES_INT_ = $(BIN2RES_INT)$(SEP)
+BIN2RES_OUT = $(OUTPUT_)$(BIN2RES_BASE)
+BIN2RES_OUT_ = $(BIN2RES_OUT)$(SEP)
+
+$(BIN2RES_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
+
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(BIN2RES_OUT): $(TOOLS_OUT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
+endif
 
 BIN2RES_TARGET = \
-       $(BIN2RES_BASE_DIR)$(SEP)bin2res$(EXEPOSTFIX)
+       $(EXEPREFIX)$(BIN2RES_OUT_)bin2res$(EXEPOSTFIX)
 
-BIN2RES_SOURCES = \
-       $(BIN2RES_BASE)$(SEP)bin2res.c \
-       $(BIN2RES_BASE)$(SEP)mkstemps.c
+BIN2RES_SOURCES = $(addprefix $(BIN2RES_BASE_), \
+       bin2res.c \
+       mkstemps.c \
+       )
 
 BIN2RES_OBJECTS = \
-       $(BIN2RES_SOURCES:.c=.o)
+       $addprefix ( $(INTERMEDIATE_), $(BIN2RES_SOURCES:.c=.o) )
 
 BIN2RES_HOST_CFLAGS = -Iinclude/wine -D__REACTOS__ -g -Werror -Wall
 
 BIN2RES_HOST_LFLAGS = -g
 
-$(BIN2RES_TARGET): $(BIN2RES_OBJECTS)
+$(BIN2RES_TARGET): $(BIN2RES_OBJECTS) $(BIN2RES_OUT)
        $(ECHO_LD)
        ${host_gcc} $(BIN2RES_OBJECTS) $(BIN2RES_HOST_LFLAGS) -o $@
 
-$(BIN2RES_BASE_DIR)$(SEP)bin2res.o: $(BIN2RES_BASE)$(SEP)bin2res.c $(BIN2RES_BASE_DIR_EXISTS)
+$(BIN2RES_INT_)bin2res.o: $(BIN2RES_BASE_)bin2res.c $(BIN2RES_INT)
        $(ECHO_CC)
        ${host_gcc} $(BIN2RES_HOST_CFLAGS) -c $< -o $@
 
-$(BIN2RES_BASE_DIR)$(SEP)mkstemps.o: $(BIN2RES_BASE)$(SEP)mkstemps.c $(BIN2RES_BASE_DIR_EXISTS)
+$(BIN2RES_INT_)mkstemps.o: $(BIN2RES_BASE_)mkstemps.c $(BIN2RES_INT)
        $(ECHO_CC)
        ${host_gcc} $(BIN2RES_HOST_CFLAGS) -c $< -o $@
 
index a027de5..6158b50 100644 (file)
@@ -1,46 +1,54 @@
-BUILDNO_BASE = $(TOOLS_BASE)$(SEP)buildno
-
-BUILDNO_BASE_DIR = $(INTERMEDIATE)$(BUILDNO_BASE)
-BUILDNO_BASE_DIR_EXISTS = $(BUILDNO_BASE_DIR)$(SEP)$(EXISTS)
+BUILDNO_BASE = $(TOOLS_BASE_)buildno
+BUILDNO_BASE_ = $(BUILDNO_BASE)$(SEP)
+BUILDNO_INT = $(INTERMEDIATE_)$(BUILDNO_BASE)
+BUILDNO_INT_ = $(BUILDNO_INT)$(SEP)
+BUILDNO_OUT = $(OUTPUT_)$(BUILDNO_BASE)
+BUILDNO_OUT_ = $(BUILDNO_OUT)$(SEP)
+
+$(BUILDNO_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(BUILDNO_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(BUILDNO_OUT): $(TOOLS_OUT)
        $(ECHO_MKDIR)
-       ${mkdir} $(BUILDNO_BASE_DIR)
-       @echo. > $@
+       ${mkdir} $@
+endif
 
 BUILDNO_TARGET = \
-       $(BUILDNO_BASE_DIR)$(SEP)buildno$(EXEPOSTFIX)
+       $(EXEPREFIX)$(BUILDNO_OUT_)buildno$(EXEPOSTFIX)
 
-BUILDNO_SOURCES = \
-       $(BUILDNO_BASE)$(SEP)buildno.cpp \
-       $(BUILDNO_BASE)$(SEP)exception.cpp \
-       $(BUILDNO_BASE)$(SEP)ssprintf.cpp \
-       $(BUILDNO_BASE)$(SEP)XML.cpp
+BUILDNO_SOURCES = $(addprefix $(BUILDNO_BASE_), \
+       buildno.cpp \
+       exception.cpp \
+       ssprintf.cpp \
+       XML.cpp \
+       )
 
 BUILDNO_OBJECTS = \
-  $(addprefix $(INTERMEDIATE), $(BUILDNO_SOURCES:.cpp=.o))
+  $(addprefix $(INTERMEDIATE_), $(BUILDNO_SOURCES:.cpp=.o))
 
 BUILDNO_HOST_CFLAGS = -Iinclude/reactos -g -Werror -Wall
 
 BUILDNO_HOST_LFLAGS = -g
 
-$(BUILDNO_TARGET): $(BUILDNO_OBJECTS)
+$(BUILDNO_TARGET): $(BUILDNO_OBJECTS) $(BUILDNO_OUT)
        $(ECHO_LD)
-       ${host_gpp} $(BUILDNO_OBJECTS) $(BUILDNO_HOST_LFLAGS) -o $(BUILDNO_TARGET)
+       ${host_gpp} $(BUILDNO_OBJECTS) $(BUILDNO_HOST_LFLAGS) -o $@
 
-$(BUILDNO_BASE_DIR)$(SEP)buildno.o: $(BUILDNO_BASE)$(SEP)buildno.cpp $(BUILDNO_BASE_DIR_EXISTS)
+$(BUILDNO_INT_)buildno.o: $(BUILDNO_BASE_)buildno.cpp $(BUILDNO_INT)
        $(ECHO_CC)
        ${host_gpp} $(BUILDNO_HOST_CFLAGS) -c $< -o $@
 
-$(BUILDNO_BASE_DIR)$(SEP)exception.o: $(BUILDNO_BASE)$(SEP)exception.cpp $(BUILDNO_BASE_DIR_EXISTS)
+$(BUILDNO_INT_)exception.o: $(BUILDNO_BASE_)exception.cpp $(BUILDNO_INT)
        $(ECHO_CC)
        ${host_gpp} $(BUILDNO_HOST_CFLAGS) -c $< -o $@
 
-$(BUILDNO_BASE_DIR)$(SEP)ssprintf.o: $(BUILDNO_BASE)$(SEP)ssprintf.cpp $(BUILDNO_BASE_DIR_EXISTS)
+$(BUILDNO_INT_)ssprintf.o: $(BUILDNO_BASE_)ssprintf.cpp $(BUILDNO_INT)
        $(ECHO_CC)
        ${host_gpp} $(BUILDNO_HOST_CFLAGS) -c $< -o $@
 
-$(BUILDNO_BASE_DIR)$(SEP)XML.o: $(BUILDNO_BASE)$(SEP)XML.cpp $(BUILDNO_BASE_DIR_EXISTS)
+$(BUILDNO_INT_)XML.o: $(BUILDNO_BASE_)XML.cpp $(BUILDNO_INT)
        $(ECHO_CC)
        ${host_gpp} $(BUILDNO_HOST_CFLAGS) -c $< -o $@
 
index c30060e..1b329c7 100755 (executable)
@@ -1,51 +1,64 @@
-CABMAN_BASE = tools$(SEP)cabman
+CABMAN_BASE = $(TOOLS_BASE_)cabman
+CABMAN_BASE_ = $(CABMAN_BASE)$(SEP)
+CABMAN_INT = $(INTERMEDIATE_)$(CABMAN_BASE)
+CABMAN_INT_ = $(CABMAN_INT)$(SEP)
+CABMAN_OUT = $(OUTPUT_)$(CABMAN_BASE)
+CABMAN_OUT_ = $(CABMAN_OUT)$(SEP)
 
-CABMAN_BASE_DIR = $(INTERMEDIATE)$(CABMAN_BASE)
+$(CABMAN_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(CABMAN_BASE_DIR): $(RMKDIR_TARGET)
-       ${mkdir} $(INTERMEDIATE)$(CABMAN_BASE)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(CABMAN_OUT): $(TOOLS_OUT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
+endif
 
 CABMAN_TARGET = \
-       $(CABMAN_BASE_DIR)$(SEP)cabman$(EXEPOSTFIX)
+       $(EXEPREFIX)$(CABMAN_OUT_)cabman$(EXEPOSTFIX)
 
-CABMAN_SOURCES = \
-       $(CABMAN_BASE)$(SEP)cabinet.cxx \
-       $(CABMAN_BASE)$(SEP)dfp.cxx \
-       $(CABMAN_BASE)$(SEP)main.cxx \
-       $(CABMAN_BASE)$(SEP)mszip.cxx \
-       $(CABMAN_BASE)$(SEP)raw.cxx
+CABMAN_SOURCES = $(addprefix $(CABMAN_INT_), \
+       cabinet.cxx \
+       dfp.cxx \
+       main.cxx \
+       mszip.cxx \
+       raw.cxx \
+       )
 
 CABMAN_OBJECTS = \
-  $(addprefix $(INTERMEDIATE), $(CABMAN_SOURCES:.cxx=.o))
+  $(addprefix $(INTERMEDIATE_), $(CABMAN_SOURCES:.cxx=.o))
 
 CABMAN_HOST_CFLAGS = -Iinclude/reactos -Ilib/zlib -g -Werror -Wall
 
-CABMAN_HOST_LFLAGS = -g $(ZLIB_HOST_TARGET)
+CABMAN_HOST_LIBS = $(ZLIB_HOST_TARGET)
+
+CABMAN_HOST_LFLAGS = -g $(CABMAN_HOST_LIBS)
 
 .PHONY: cabman
 cabman: $(CABMAN_TARGET)
 
-$(CABMAN_TARGET): $(CABMAN_OBJECTS) $(ZLIB_HOST_TARGET)
+$(CABMAN_TARGET): $(CABMAN_OBJECTS) $(CABMAN_HOST_LIBS) $(CABMAN_OUT)
        $(ECHO_LD)
        ${host_gpp} $(CABMAN_OBJECTS) $(CABMAN_HOST_LFLAGS) -o $@
 
-$(CABMAN_BASE_DIR)$(SEP)cabinet.o: $(CABMAN_BASE)$(SEP)cabinet.cxx $(CABMAN_BASE_DIR)
+$(CABMAN_INT_)cabinet.o: $(CABMAN_BASE_)cabinet.cxx $(CABMAN_BASE_DIR)
        $(ECHO_CC)
        ${host_gpp} $(CABMAN_HOST_CFLAGS) -c $< -o $@
 
-$(CABMAN_BASE_DIR)$(SEP)dfp.o: $(CABMAN_BASE)$(SEP)dfp.cxx $(CABMAN_BASE_DIR)
+$(CABMAN_INT_)dfp.o: $(CABMAN_BASE_)dfp.cxx $(CABMAN_BASE_DIR)
        $(ECHO_CC)
        ${host_gpp} $(CABMAN_HOST_CFLAGS) -c $< -o $@
 
-$(CABMAN_BASE_DIR)$(SEP)main.o: $(CABMAN_BASE)$(SEP)main.cxx $(CABMAN_BASE_DIR)
+$(CABMAN_INT_)main.o: $(CABMAN_BASE_)main.cxx $(CABMAN_BASE_DIR)
        $(ECHO_CC)
        ${host_gpp} $(CABMAN_HOST_CFLAGS) -c $< -o $@
 
-$(CABMAN_BASE_DIR)$(SEP)mszip.o: $(CABMAN_BASE)$(SEP)mszip.cxx $(CABMAN_BASE_DIR)
+$(CABMAN_INT_)mszip.o: $(CABMAN_BASE_)mszip.cxx $(CABMAN_BASE_DIR)
        $(ECHO_CC)
        ${host_gpp} $(CABMAN_HOST_CFLAGS) -c $< -o $@
 
-$(CABMAN_BASE_DIR)$(SEP)raw.o: $(CABMAN_BASE)$(SEP)raw.cxx $(CABMAN_BASE_DIR)
+$(CABMAN_INT_)raw.o: $(CABMAN_BASE_)raw.cxx $(CABMAN_BASE_DIR)
        $(ECHO_CC)
        ${host_gpp} $(CABMAN_HOST_CFLAGS) -c $< -o $@
 
index 8a1c40b..46036c6 100644 (file)
@@ -1,22 +1,30 @@
-CDMAKE_BASE = $(TOOLS_BASE)$(SEP)cdmake
-
-CDMAKE_BASE_DIR = $(INTERMEDIATE)$(CDMAKE_BASE)
-CDMAKE_BASE_DIR_EXISTS = $(CDMAKE_BASE_DIR)$(SEP)$(EXISTS)
+CDMAKE_BASE = $(TOOLS_BASE_)cdmake
+CDMAKE_BASE_ = $(CDMAKE_BASE)$(SEP)
+CDMAKE_INT = $(INTERMEDIATE_)$(CDMAKE_BASE)
+CDMAKE_INT_ = $(CDMAKE_INT)$(SEP)
+CDMAKE_OUT = $(OUTPUT_)$(CDMAKE_BASE)
+CDMAKE_OUT_ = $(CDMAKE_OUT)$(SEP)
+
+$(CDMAKE_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(CDMAKE_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(CDMAKE_OUT): $(TOOLS_OUT)
        $(ECHO_MKDIR)
-       ${mkdir} $(CDMAKE_BASE_DIR)
-       @echo . >$@
+       ${mkdir} $@
+endif
 
 CDMAKE_TARGET = \
-       $(CDMAKE_BASE_DIR)$(SEP)cdmake$(EXEPOSTFIX)
+       $(EXEPREFIX)$(CDMAKE_OUT_)cdmake$(EXEPOSTFIX)
 
-CDMAKE_SOURCES = \
-       $(CDMAKE_BASE)$(SEP)cdmake.c \
-       $(CDMAKE_BASE)$(SEP)llmosrt.c
+CDMAKE_SOURCES = $(addprefix $(CDMAKE_BASE_), \
+       cdmake.c \
+       llmosrt.c \
+       )
 
 CDMAKE_OBJECTS = \
-       $(addprefix $(INTERMEDIATE), $(CDMAKE_SOURCES:.c=.o))
+       $(addprefix $(INTERMEDIATE_), $(CDMAKE_SOURCES:.c=.o))
 
 CDMAKE_HOST_CFLAGS = -Iinclude -g -Werror -Wall
 
@@ -25,15 +33,15 @@ CDMAKE_HOST_LFLAGS = -g
 .PHONY: cdmake
 cdmake: $(CDMAKE_TARGET)
 
-$(CDMAKE_TARGET): $(CDMAKE_OBJECTS)
+$(CDMAKE_TARGET): $(CDMAKE_OBJECTS) $(CDMAKE_OUT)
        $(ECHO_LD)
        ${host_gcc} $(CDMAKE_OBJECTS) $(CDMAKE_HOST_LFLAGS) -o $@
 
-$(CDMAKE_BASE_DIR)$(SEP)cdmake.o: $(CDMAKE_BASE)$(SEP)cdmake.c $(CDMAKE_BASE_DIR_EXISTS)
+$(CDMAKE_INT_)cdmake.o: $(CDMAKE_BASE_)cdmake.c $(CDMAKE_INT)
        $(ECHO_CC)
        ${host_gcc} $(CDMAKE_HOST_CFLAGS) -c $< -o $@
 
-$(CDMAKE_BASE_DIR)$(SEP)llmosrt.o: $(CDMAKE_BASE)$(SEP)llmosrt.c $(CDMAKE_BASE_DIR_EXISTS)
+$(CDMAKE_INT_)llmosrt.o: $(CDMAKE_BASE_)llmosrt.c $(CDMAKE_INT)
        $(ECHO_CC)
        ${host_gcc} $(CDMAKE_HOST_CFLAGS) -c $< -o $@
 
index 56c492d..53d9df1 100644 (file)
@@ -1,30 +1,38 @@
-NCI_BASE = $(TOOLS_BASE)$(SEP)nci
+NCI_BASE = $(TOOLS_BASE_)nci
+NCI_BASE_ = $(NCI_BASE)$(SEP)
+NCI_INT = $(INTERMEDIATE_)$(NCI_BASE)
+NCI_INT_ = $(NCI_INT)$(SEP)
+NCI_OUT = $(OUTPUT_)$(NCI_BASE)
+NCI_OUT_ = $(NCI_OUT)$(SEP)
 
-NCI_BASE_DIR = $(INTERMEDIATE)$(NCI_BASE)
-NCI_BASE_DIR_EXISTS = $(NCI_BASE_DIR)$(SEP)$(EXISTS)
+$(NCI_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(NCI_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXIST)
-       ${mkdir} $(NCI_BASE_DIR)
-       @echo . > $@
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(NCI_OUT): $(TOOLS_OUT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
+endif
 
 NCI_TARGET = \
-       $(NCI_BASE_DIR)$(SEP)nci$(EXEPOSTFIX)
+       $(EXEPREFIX)$(NCI_OUT_)nci$(EXEPOSTFIX)
 
 NCI_SOURCES = \
-       $(NCI_BASE)$(SEP)ncitool.c
+       $(NCI_BASE_)ncitool.c
 
 NCI_OBJECTS = \
-    $(addprefix $(INTERMEDIATE), $(NCI_SOURCES:.c=.o))
+    $(addprefix $(INTERMEDIATE_), $(NCI_SOURCES:.c=.o))
 
 NCI_HOST_CFLAGS = -Iinclude -g -Werror -Wall
 
 NCI_HOST_LFLAGS = -g
 
-$(NCI_TARGET): $(NCI_OBJECTS)
+$(NCI_TARGET): $(NCI_OBJECTS) $(NCI_OUT)
        $(ECHO_LD)
-       ${host_gcc} $(NCI_OBJECTS) $(NCI_HOST_CFLAGS) -o $(NCI_TARGET)
+       ${host_gcc} $(NCI_OBJECTS) $(NCI_HOST_LFLAGS) -o $@
 
-$(NCI_BASE_DIR)$(SEP)ncitool.o: $(NCI_BASE)$(SEP)ncitool.c $(NCI_BASE_DIR_EXISTS)
+$(NCI_INT_)ncitool.o: $(NCI_BASE_)ncitool.c $(NCI_INT)
        $(ECHO_CC)
        ${host_gcc} $(NCI_HOST_CFLAGS) -c $< -o $@
 
@@ -34,13 +42,13 @@ nci_clean:
 clean: nci_clean
 
 # WIN32K.SYS
-WIN32K_SVC_DB = $(NCI_BASE)$(SEP)w32ksvc.db
+WIN32K_SVC_DB = $(NCI_BASE_)w32ksvc.db
 WIN32K_SERVICE_TABLE = subsys$(SEP)win32k$(SEP)main$(SEP)svctab.c
 WIN32K_GDI_STUBS = lib$(SEP)gdi32$(SEP)misc$(SEP)win32k.S
 WIN32K_USER_STUBS = lib$(SEP)user32$(SEP)misc$(SEP)win32k.S
 
 # NTOSKRNL.EXE
-KERNEL_SVC_DB = $(NCI_BASE)$(SEP)sysfuncs.lst
+KERNEL_SVC_DB = $(NCI_BASE_)sysfuncs.lst
 KERNEL_SERVICE_TABLE = include$(SEP)ntdll$(SEP)napi.h
 NTDLL_STUBS = lib$(SEP)ntdll$(SEP)napi.S
 KERNEL_STUBS = ntoskrnl$(SEP)ex$(SEP)zw.S
index 2085534..2d969e7 100644 (file)
@@ -3,12 +3,75 @@
 \r
 #include "mingw.h"\r
 #include <assert.h>\r
+#include "modulehandler.h"\r
 \r
 using std::string;\r
 using std::vector;\r
 using std::set;\r
+using std::map;\r
 \r
 typedef set<string> set_string;\r
+typedef map<string,Directory*> directory_map;\r
+\r
+class Directory\r
+{\r
+public:\r
+       string name;\r
+       directory_map subdirs;\r
+       Directory ( const string& name );\r
+       void Add ( const char* subdir );\r
+       void CreateRule ( FILE* f, const string& parent );\r
+};\r
+\r
+Directory::Directory ( const string& name_ )\r
+       : name(name_)\r
+{\r
+}\r
+\r
+void Directory::Add ( const char* subdir )\r
+{\r
+       const char* p = strpbrk ( subdir, "/\\" );\r
+       if ( !p )\r
+               p = subdir + strlen(subdir);\r
+       string s ( subdir, p-subdir );\r
+       if ( subdirs.find(s) == subdirs.end() )\r
+               subdirs[s] = new Directory(s);\r
+       if ( *p && *++p )\r
+               subdirs[s]->Add ( p );\r
+}\r
+\r
+void\r
+Directory::CreateRule ( FILE* f, const string& parent )\r
+{\r
+       string path;\r
+\r
+       if ( parent.size() )\r
+       {\r
+               fprintf ( f,\r
+                       "%s%c%s: %s\n",\r
+                       parent.c_str (),\r
+                       CSEP,\r
+                       name.c_str (),\r
+                       parent.c_str () );\r
+\r
+               fprintf ( f,\r
+                       "\t$(ECHO_MKDIR)\n" );\r
+\r
+               fprintf ( f,\r
+                       "\t${mkdir} $@\n" );\r
+\r
+               path = parent + SSEP + name;\r
+       }\r
+       else\r
+               path = name;\r
+\r
+       for ( directory_map::iterator i = subdirs.begin();\r
+               i != subdirs.end();\r
+               ++i )\r
+       {\r
+               i->second->CreateRule ( f, path );\r
+       }\r
+}\r
 \r
 static class MingwFactory : public Backend::Factory\r
 {\r
@@ -22,33 +85,82 @@ public:
 \r
 \r
 MingwBackend::MingwBackend ( Project& project )\r
-       : Backend ( project )\r
+       : Backend ( project ),\r
+         int_directories ( new Directory("$(INTERMEDIATE)") ),\r
+         out_directories ( new Directory("$(OUTPUT)") )\r
 {\r
 }\r
 \r
-void\r
-MingwBackend::CreateDirectoryTargetIfNotYetCreated ( const string& directory )\r
+MingwBackend::~MingwBackend()\r
 {\r
-       directories.insert ( directory );\r
+       delete int_directories;\r
+       delete out_directories;\r
 }\r
 \r
+string\r
+MingwBackend::AddDirectoryTarget ( const string& directory, bool out )\r
+{\r
+       const char* dir_name = "$(INTERMEDIATE)";\r
+       Directory* dir = int_directories;\r
+       if ( out )\r
+       {\r
+               dir_name = "$(OUTPUT)";\r
+               dir = out_directories;\r
+       }\r
+       dir->Add ( directory.c_str() );\r
+       return dir_name;\r
+}\r
 \r
 void\r
 MingwBackend::Process ()\r
 {\r
+       size_t i;\r
+\r
        DetectPCHSupport();\r
 \r
        CreateMakefile ();\r
        GenerateHeader ();\r
        GenerateGlobalVariables ();\r
-       GenerateAllTarget ();\r
-       GenerateInitTarget ();\r
        GenerateXmlBuildFilesMacro();\r
-       for ( size_t i = 0; i < ProjectNode.modules.size (); i++ )\r
+\r
+       vector<MingwModuleHandler*> v;\r
+\r
+       for ( i = 0; i < ProjectNode.modules.size (); i++ )\r
        {\r
                Module& module = *ProjectNode.modules[i];\r
-               ProcessModule ( module );\r
+               MingwModuleHandler* h = MingwModuleHandler::InstanciateHandler (\r
+                       module,\r
+                       this );\r
+               if ( module.host == HostDefault )\r
+               {\r
+                       module.host = h->DefaultHost();\r
+                       assert ( module.host != HostDefault );\r
+               }\r
+               v.push_back ( h );\r
+       }\r
+\r
+       size_t iend = v.size ();\r
+\r
+       for ( i = 0; i < iend; i++ )\r
+               v[i]->GenerateTargetMacro();\r
+       fprintf ( fMakefile, "\n" );\r
+\r
+       GenerateAllTarget ( v );\r
+       GenerateInitTarget ();\r
+\r
+       for ( i = 0; i < iend; i++ )\r
+               v[i]->GenerateOtherMacros();\r
+\r
+       for ( i = 0; i < iend; i++ )\r
+       {\r
+               MingwModuleHandler& h = *v[i];\r
+               h.GeneratePreconditionDependencies ();\r
+               h.Process ();\r
+               h.GenerateInvocations ();\r
+               h.GenerateCleanTarget ();\r
+               delete v[i];\r
        }\r
+\r
        GenerateDirectoryTargets ();\r
        CheckAutomaticDependencies ();\r
        CloseMakefile ();\r
@@ -60,6 +172,7 @@ MingwBackend::CreateMakefile ()
        fMakefile = fopen ( ProjectNode.makefile.c_str (), "w" );\r
        if ( !fMakefile )\r
                throw AccessDeniedException ( ProjectNode.makefile );\r
+       MingwModuleHandler::SetBackend ( this );\r
        MingwModuleHandler::SetMakefile ( fMakefile );\r
        MingwModuleHandler::SetUsePch ( use_pch );\r
 }\r
@@ -129,7 +242,7 @@ MingwBackend::GenerateGlobalCFlagsAndProperties (
        if ( data.includes.size() || data.defines.size() )\r
        {\r
                GenerateProjectCFlagsMacro ( assignmentOperation,\r
-                                     data );\r
+                                            data );\r
        }\r
 \r
        for ( i = 0; i < data.ifs.size(); i++ )\r
@@ -171,15 +284,6 @@ MingwBackend::GenerateProjectLFLAGS () const
 void\r
 MingwBackend::GenerateGlobalVariables () const\r
 {\r
-#define TOOL_PREFIX "$(Q)$(INTERMEDIATE)tools" SSEP\r
-       fprintf ( fMakefile, "winebuild = " TOOL_PREFIX "winebuild" SSEP "winebuild" EXEPOSTFIX "\n" );\r
-       fprintf ( fMakefile, "bin2res = " TOOL_PREFIX "bin2res" SSEP "bin2res" EXEPOSTFIX "\n" );\r
-       fprintf ( fMakefile, "cabman = " TOOL_PREFIX "cabman" SSEP "cabman" EXEPOSTFIX "\n" );\r
-       fprintf ( fMakefile, "cdmake = " TOOL_PREFIX "cdmake" SSEP "cdmake" EXEPOSTFIX "\n" );\r
-       fprintf ( fMakefile, "regtests = " TOOL_PREFIX "regtests" EXEPOSTFIX "\n" );\r
-       fprintf ( fMakefile, "rsym = " TOOL_PREFIX "rsym" EXEPOSTFIX "\n" );\r
-       fprintf ( fMakefile, "wrc = " TOOL_PREFIX "wrc" SSEP "wrc" EXEPOSTFIX "\n" );\r
-       fprintf ( fMakefile, "\n" );\r
        GenerateGlobalCFlagsAndProperties (\r
                "=",\r
                ProjectNode.non_if_data );\r
@@ -202,20 +306,21 @@ MingwBackend::IncludeInAllTarget ( const Module& module ) const
 }\r
 \r
 void\r
-MingwBackend::GenerateAllTarget () const\r
+MingwBackend::GenerateAllTarget ( const vector<MingwModuleHandler*>& handlers ) const\r
 {\r
        fprintf ( fMakefile, "all:" );\r
        int wrap_count = 0;\r
-       for ( size_t i = 0; i < ProjectNode.modules.size (); i++ )\r
+       size_t iend = handlers.size ();\r
+       for ( size_t i = 0; i < iend; i++ )\r
        {\r
-               Module& module = *ProjectNode.modules[i];\r
+               const Module& module = handlers[i]->module;\r
                if ( IncludeInAllTarget ( module ) )\r
                {\r
                        if ( wrap_count++ == 5 )\r
                                fprintf ( fMakefile, " \\\n\t\t" ), wrap_count = 0;\r
                        fprintf ( fMakefile,\r
                                  " %s",\r
-                                 FixupTargetFilename ( module.GetPath () ).c_str () );\r
+                                 GetTargetMacro(module).c_str () );\r
                }\r
        }\r
        fprintf ( fMakefile, "\n\t\n\n" );\r
@@ -244,8 +349,7 @@ MingwBackend::GenerateInitTarget () const
        fprintf ( fMakefile,\r
                  "INIT = %s\n",\r
                  GetBuildToolDependencies ().c_str () );\r
-       fprintf ( fMakefile,\r
-                 "\n" );\r
+       fprintf ( fMakefile, "\n" );\r
 }\r
 \r
 void\r
@@ -272,8 +376,7 @@ MingwBackend::GenerateXmlBuildFilesMacro() const
                                  xmlbuildFilenames.c_str ());\r
                        if ( i == ProjectNode.xmlbuildfiles.size () - 1 )\r
                        {\r
-                               fprintf ( fMakefile,\r
-                                         "\n" );\r
+                               fprintf ( fMakefile, "\n" );\r
                        }\r
                        else\r
                        {\r
@@ -285,8 +388,7 @@ MingwBackend::GenerateXmlBuildFilesMacro() const
                }\r
                numberOfExistingFiles++;\r
        }\r
-       fprintf ( fMakefile,\r
-                 "\n" );\r
+       fprintf ( fMakefile, "\n" );\r
 }\r
 \r
 void\r
@@ -297,27 +399,10 @@ MingwBackend::CheckAutomaticDependencies ()
        automaticDependency.CheckAutomaticDependencies ();\r
 }\r
 \r
-void\r
-MingwBackend::ProcessModule ( Module& module )\r
-{\r
-       MingwModuleHandler* h = MingwModuleHandler::InstanciateHandler (\r
-               module.node.location,\r
-               module.type,\r
-           this );\r
-       MingwModuleHandler::string_list clean_files;\r
-       if ( module.host == HostDefault )\r
-       {\r
-               module.host = h->DefaultHost();\r
-               assert ( module.host != HostDefault );\r
-       }\r
-       h->Process ( module, clean_files );\r
-       h->GenerateCleanTarget ( module, clean_files );\r
-}\r
-\r
 bool\r
 MingwBackend::IncludeDirectoryTarget ( const string& directory ) const\r
 {\r
-       if ( directory == "$(INTERMEDIATE)tools")\r
+       if ( directory == "$(INTERMEDIATE)" SSEP "tools")\r
                return false;\r
        else\r
                return true;\r
@@ -326,7 +411,15 @@ MingwBackend::IncludeDirectoryTarget ( const string& directory ) const
 void\r
 MingwBackend::GenerateDirectoryTargets ()\r
 {\r
-       if ( directories.size () == 0 )\r
+       // TODO FIXME - write new directory creation\r
+       for ( int i = 0; i < 2; i++ )\r
+       {\r
+               Directory& d = *(!i ? int_directories : out_directories);\r
+               if ( i ) fprintf ( fMakefile, "ifneq ($(INTERMEDIATE),$(OUTPUT))\n" );\r
+               d.CreateRule ( fMakefile, "" );\r
+               if ( i ) fprintf ( fMakefile, "endif\n" );\r
+       }\r
+       /*if ( directories.size () == 0 )\r
                return;\r
        \r
        set_string::iterator i;\r
@@ -345,13 +438,13 @@ MingwBackend::GenerateDirectoryTargets ()
                }\r
        }\r
 \r
-       directories.clear ();\r
+       directories.clear ();*/\r
 }\r
 \r
 string\r
 FixupTargetFilename ( const string& targetFilename )\r
 {\r
-       return string("$(INTERMEDIATE)") + NormalizeFilename ( targetFilename );\r
+       return NormalizeFilename ( targetFilename );\r
 }\r
 \r
 void\r
index fc8b38c..35c4f31 100644 (file)
@@ -2,17 +2,18 @@
 #define MINGW_H\r
 \r
 #include "../backend.h"\r
-#include "modulehandler.h"\r
+\r
+class Directory;\r
+class MingwModuleHandler;\r
 \r
 class MingwBackend : public Backend\r
 {\r
 public:\r
        MingwBackend ( Project& project );\r
-       virtual ~MingwBackend () { };\r
+       virtual ~MingwBackend ();\r
        virtual void Process ();\r
-       void CreateDirectoryTargetIfNotYetCreated ( const std::string& directory );\r
+       std::string AddDirectoryTarget ( const std::string& directory, bool out );\r
 private:\r
-       void ProcessModule ( Module& module );\r
        void CreateMakefile ();\r
        void CloseMakefile () const;\r
        void GenerateHeader () const;\r
@@ -24,16 +25,16 @@ private:
        void GenerateDirectoryTargets ();\r
        void GenerateGlobalVariables () const;\r
        bool IncludeInAllTarget ( const Module& module ) const;\r
-       void GenerateAllTarget () const;\r
+       void GenerateAllTarget ( const std::vector<MingwModuleHandler*>& handlers ) const;\r
        std::string GetBuildToolDependencies () const;\r
        void GenerateInitTarget () const;\r
        void GenerateXmlBuildFilesMacro() const;\r
        void CheckAutomaticDependencies ();\r
        bool IncludeDirectoryTarget ( const std::string& directory ) const;\r
        void DetectPCHSupport();\r
-       std::set<std::string> directories;\r
        FILE* fMakefile;\r
        bool use_pch;\r
+       Directory *int_directories, *out_directories;\r
 };\r
 \r
 std::string FixupTargetFilename ( const std::string& targetFilename );\r
index 7a8a300..35b3248 100644 (file)
@@ -10,28 +10,14 @@ using std::vector;
 \r
 #define CLEAN_FILE(f) clean_files.push_back ( f ); /*if ( module.name == "crt" ) printf ( "%s(%i): clean: %s\n", __FILE__, __LINE__, f.c_str() )*/\r
 \r
+static string ros_temp = "$(ROS_TEMPORARY)";\r
+MingwBackend*\r
+MingwModuleHandler::backend = NULL;\r
 FILE*\r
 MingwModuleHandler::fMakefile = NULL;\r
 bool\r
 MingwModuleHandler::use_pch = false;\r
 \r
-string\r
-ReplaceExtension ( const string& filename,\r
-                   const string& newExtension )\r
-{\r
-       size_t index = filename.find_last_of ( '/' );\r
-       if ( index == string::npos )\r
-               index = 0;\r
-       size_t index2 = filename.find_last_of ( '\\' );\r
-       if ( index2 != string::npos && index2 > index )\r
-               index = index2;\r
-       string tmp = filename.substr( index /*, filename.size() - index*/ );\r
-       size_t ext_index = tmp.find_last_of( '.' );\r
-       if ( ext_index != string::npos )\r
-               return filename.substr ( 0, index + ext_index ) + newExtension;\r
-       return filename + newExtension;\r
-}\r
-\r
 string\r
 PrefixFilename (\r
        const string& filename,\r
@@ -54,7 +40,8 @@ PrefixFilename (
        return out;\r
 }\r
 \r
-string v2s ( const vector<string>& v, int wrap_at )\r
+string\r
+v2s ( const string_list& v, int wrap_at )\r
 {\r
        if ( !v.size() )\r
                return "";\r
@@ -73,9 +60,21 @@ string v2s ( const vector<string>& v, int wrap_at )
        return s;\r
 }\r
 \r
-MingwModuleHandler::MingwModuleHandler ( ModuleType moduletype,\r
-                                         MingwBackend* backend_ )\r
-       : backend ( backend_ )\r
+string\r
+GetTargetMacro ( const Module& module, bool with_dollar )\r
+{\r
+       string s ( module.name );\r
+       strupr ( &s[0] );\r
+       s += "_TARGET";\r
+       if ( with_dollar )\r
+               return ssprintf ( "$(%s)", s.c_str() );\r
+       return s;\r
+}\r
+\r
+MingwModuleHandler::MingwModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : module(module_)\r
 {\r
 }\r
 \r
@@ -83,77 +82,121 @@ MingwModuleHandler::~MingwModuleHandler()
 {\r
 }\r
 \r
-const string &\r
-MingwModuleHandler::PassThruCacheDirectory ( const string &file )\r
+/*static*/ void\r
+MingwModuleHandler::SetBackend ( MingwBackend* backend_ )\r
 {\r
-       backend->CreateDirectoryTargetIfNotYetCreated ( GetDirectory ( file ) );\r
-       return file;\r
+       backend = backend_;\r
 }\r
 \r
-void\r
+/*static*/ void\r
 MingwModuleHandler::SetMakefile ( FILE* f )\r
 {\r
        fMakefile = f;\r
 }\r
 \r
-void\r
+/*static*/ void\r
 MingwModuleHandler::SetUsePch ( bool b )\r
 {\r
        use_pch = b;\r
 }\r
 \r
-MingwModuleHandler*\r
-MingwModuleHandler::InstanciateHandler ( const string& location,\r
-                                         ModuleType moduletype,\r
-                                         MingwBackend* backend )\r
+/*static*/ string\r
+MingwModuleHandler::PassThruCacheDirectory (\r
+       const string &file, bool out )\r
+{\r
+       string dir ( GetDirectory ( file ) );\r
+       return backend->AddDirectoryTarget ( dir, out ) + SSEP + file;\r
+}\r
+\r
+/*static*/ string\r
+MingwModuleHandler::GetTargetFilename (\r
+       const Module& module,\r
+       string_list* pclean_files )\r
+{\r
+       string target = PassThruCacheDirectory (\r
+               FixupTargetFilename ( module.GetPath () ),\r
+               true );\r
+       if ( pclean_files )\r
+       {\r
+               string_list& clean_files = *pclean_files;\r
+               CLEAN_FILE ( target );\r
+       }\r
+       return target;\r
+}\r
+\r
+/*static*/ string\r
+MingwModuleHandler::GetImportLibraryFilename (\r
+       const Module& module,\r
+       string_list* pclean_files )\r
+{\r
+       string target = PassThruCacheDirectory (\r
+               FixupTargetFilename ( module.GetDependencyPath () ),\r
+               true );\r
+       if ( pclean_files )\r
+       {\r
+               string_list& clean_files = *pclean_files;\r
+               CLEAN_FILE ( target );\r
+       }\r
+       return target;\r
+}\r
+\r
+/*static*/ MingwModuleHandler*\r
+MingwModuleHandler::InstanciateHandler (\r
+       const Module& module,\r
+       MingwBackend* backend )\r
 {\r
        MingwModuleHandler* handler;\r
-       switch ( moduletype )\r
+       switch ( module.type )\r
        {\r
                case BuildTool:\r
-                       handler = new MingwBuildToolModuleHandler ( backend );\r
+                       handler = new MingwBuildToolModuleHandler ( module );\r
                        break;\r
                case StaticLibrary:\r
-                       handler = new MingwStaticLibraryModuleHandler ( backend );\r
+                       handler = new MingwStaticLibraryModuleHandler ( module );\r
                        break;\r
                case ObjectLibrary:\r
-                       handler = new MingwObjectLibraryModuleHandler ( backend );\r
+                       handler = new MingwObjectLibraryModuleHandler ( module );\r
                        break;\r
                case Kernel:\r
-                       handler = new MingwKernelModuleHandler ( backend );\r
+                       handler = new MingwKernelModuleHandler ( module );\r
                        break;\r
                case NativeCUI:\r
-                       handler = new MingwNativeCUIModuleHandler ( backend );\r
+                       handler = new MingwNativeCUIModuleHandler ( module );\r
                        break;\r
                case Win32CUI:\r
-                       handler = new MingwWin32CUIModuleHandler ( backend );\r
+                       handler = new MingwWin32CUIModuleHandler ( module );\r
                        break;\r
                case Win32GUI:\r
-                       handler = new MingwWin32GUIModuleHandler ( backend );\r
+                       handler = new MingwWin32GUIModuleHandler ( module );\r
                        break;\r
                case KernelModeDLL:\r
-                       handler = new MingwKernelModeDLLModuleHandler ( backend );\r
+                       handler = new MingwKernelModeDLLModuleHandler ( module );\r
                        break;\r
                case NativeDLL:\r
-                       handler = new MingwNativeDLLModuleHandler ( backend );\r
+                       handler = new MingwNativeDLLModuleHandler ( module );\r
                        break;\r
                case Win32DLL:\r
-                       handler = new MingwWin32DLLModuleHandler ( backend );\r
+                       handler = new MingwWin32DLLModuleHandler ( module );\r
                        break;\r
                case KernelModeDriver:\r
-                       handler = new MingwKernelModeDriverModuleHandler ( backend );\r
+                       handler = new MingwKernelModeDriverModuleHandler ( module );\r
                        break;\r
                case BootLoader:\r
-                       handler = new MingwBootLoaderModuleHandler ( backend );\r
+                       handler = new MingwBootLoaderModuleHandler ( module );\r
                        break;\r
                case BootSector:\r
-                       handler = new MingwBootSectorModuleHandler ( backend );\r
+                       handler = new MingwBootSectorModuleHandler ( module );\r
                        break;\r
                case Iso:\r
-                       handler = new MingwIsoModuleHandler ( backend );\r
+                       handler = new MingwIsoModuleHandler ( module );\r
                        break;\r
                case Test:\r
-                       handler = new MingwTestModuleHandler ( backend );\r
+                       handler = new MingwTestModuleHandler ( module );\r
+                       break;\r
+               default:\r
+                       throw UnknownModuleTypeException (\r
+                               module.node.location,\r
+                               module.type );\r
                        break;\r
        }\r
        return handler;\r
@@ -175,7 +218,8 @@ MingwModuleHandler::GetBasename ( const string& filename ) const
 }\r
 \r
 string\r
-MingwModuleHandler::GetActualSourceFilename ( const string& filename ) const\r
+MingwModuleHandler::GetActualSourceFilename (\r
+       const string& filename ) const\r
 {\r
        string extension = GetExtension ( filename );\r
        if ( extension == ".spec" || extension == "SPEC" )\r
@@ -188,66 +232,69 @@ MingwModuleHandler::GetActualSourceFilename ( const string& filename ) const
 }\r
 \r
 string\r
-MingwModuleHandler::GetModuleArchiveFilename ( const Module& module ) const\r
+MingwModuleHandler::GetModuleArchiveFilename () const\r
 {\r
-       return ReplaceExtension ( FixupTargetFilename ( module.GetPath () ),\r
-                                 ".a" );\r
+       if ( module.type == StaticLibrary )\r
+               return GetTargetFilename(module,NULL);\r
+       return PassThruCacheDirectory ( ReplaceExtension (\r
+               FixupTargetFilename ( module.GetPath () ),\r
+               ".temp.a" ), false );\r
 }\r
 \r
 bool\r
 MingwModuleHandler::IsGeneratedFile ( const File& file ) const\r
 {\r
        string extension = GetExtension ( file.name );\r
-       if ( extension == ".spec" || extension == "SPEC" )\r
-               return true;\r
-       else\r
-               return false;\r
+       return ( extension == ".spec" || extension == "SPEC" );\r
 }\r
 \r
 string\r
-MingwModuleHandler::GetImportLibraryDependency ( const Module& importedModule )\r
+MingwModuleHandler::GetImportLibraryDependency (\r
+       const Module& importedModule )\r
 {\r
+       string dep;\r
        if ( importedModule.type == ObjectLibrary )\r
-               return GetObjectsMacro ( importedModule );\r
+               dep = GetTargetMacro ( importedModule );\r
        else\r
-               return PassThruCacheDirectory ( FixupTargetFilename ( importedModule.GetDependencyPath () ) );\r
+               dep = GetImportLibraryFilename ( importedModule, NULL );\r
+       return dep;\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetModuleDependencies ( const Module& module )\r
+void\r
+MingwModuleHandler::GetModuleDependencies (\r
+       string_list& dependencies )\r
 {\r
-       if ( module.dependencies.size () == 0 )\r
-               return "";\r
+       size_t iend = module.dependencies.size ();\r
+\r
+       // TODO FIXME - do we *really* not want to call\r
+       // GetDefinitionDependencies() if dependencies.size() == 0 ???\r
+       if ( iend == 0 )\r
+               return;\r
        \r
-       string dependencies ( "" );\r
-       for ( size_t i = 0; i < module.dependencies.size (); i++ )\r
+       for ( size_t i = 0; i < iend; i++ )\r
        {\r
-               if ( dependencies.size () > 0 )\r
-                       dependencies += " ";\r
-               const Dependency* dependency = module.dependencies[i];\r
-               const Module* dependencyModule = dependency->dependencyModule;\r
-               dependencies += dependencyModule->GetTargets ();\r
-       }\r
-       string definitionDependencies = GetDefinitionDependencies ( module );\r
-       if ( dependencies.length () > 0 && definitionDependencies.length () > 0 )\r
-               dependencies += " " + definitionDependencies;\r
-       else if ( definitionDependencies.length () > 0 )\r
-               dependencies = definitionDependencies;\r
-       return dependencies;\r
+               const Dependency& dependency = *module.dependencies[i];\r
+               const Module& dependencyModule = *dependency.dependencyModule;\r
+               dependencyModule.GetTargets ( dependencies );\r
+       }\r
+       GetDefinitionDependencies ( dependencies );\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetSourceFilenames ( const Module& module,\r
-                                         bool includeGeneratedFiles ) const\r
+void\r
+MingwModuleHandler::GetSourceFilenames (\r
+       string_list& list,\r
+       bool includeGeneratedFiles ) const\r
 {\r
        size_t i;\r
 \r
-       string sourceFilenames ( "" );\r
        const vector<File*>& files = module.non_if_data.files;\r
        for ( i = 0; i < files.size (); i++ )\r
        {\r
                if ( includeGeneratedFiles || !IsGeneratedFile ( *files[i] ) )\r
-                       sourceFilenames += " " + GetActualSourceFilename ( files[i]->name );\r
+               {\r
+                       list.push_back (\r
+                               GetActualSourceFilename ( files[i]->name ) );\r
+               }\r
        }\r
        // intentionally make a copy so that we can append more work in\r
        // the middle of processing without having to go recursive\r
@@ -265,28 +312,25 @@ MingwModuleHandler::GetSourceFilenames ( const Module& module,
                {\r
                        File& file = *files[j];\r
                        if ( includeGeneratedFiles || !IsGeneratedFile ( file ) )\r
-                               sourceFilenames += " " + GetActualSourceFilename ( file.name );\r
+                       {\r
+                               list.push_back (\r
+                                       GetActualSourceFilename ( file.name ) );\r
+                       }\r
                }\r
        }\r
-       return sourceFilenames;\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetSourceFilenames ( const Module& module ) const\r
+void\r
+MingwModuleHandler::GetSourceFilenamesWithoutGeneratedFiles (\r
+       string_list& list ) const\r
 {\r
-       return GetSourceFilenames ( module,\r
-                                   true );\r
+       GetSourceFilenames ( list, false );\r
 }\r
 \r
 string\r
-MingwModuleHandler::GetSourceFilenamesWithoutGeneratedFiles ( const Module& module ) const\r
-{\r
-       return GetSourceFilenames ( module,\r
-                                   false );\r
-}\r
-\r
-static string\r
-GetObjectFilename ( const Module& module, const string& sourceFilename )\r
+MingwModuleHandler::GetObjectFilename (\r
+       const string& sourceFilename,\r
+       string_list* pclean_files ) const\r
 {\r
        string newExtension;\r
        string extension = GetExtension ( sourceFilename );\r
@@ -296,16 +340,22 @@ GetObjectFilename ( const Module& module, const string& sourceFilename )
                newExtension = ".stubs.o";\r
        else\r
                newExtension = ".o";\r
-       return FixupTargetFilename (\r
-               ReplaceExtension (\r
-                       PrefixFilename(sourceFilename,module.prefix),\r
-                       newExtension ) );\r
+       string obj_file = PassThruCacheDirectory (\r
+               FixupTargetFilename (\r
+                       ReplaceExtension (\r
+                               sourceFilename, //PrefixFilename(sourceFilename,module.prefix),\r
+                               newExtension ) ),\r
+                       false );\r
+       if ( pclean_files )\r
+       {\r
+               string_list& clean_files = *pclean_files;\r
+               CLEAN_FILE ( obj_file );\r
+       }\r
+       return obj_file;\r
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateCleanTarget (\r
-       const Module& module,\r
-       const string_list& clean_files ) const\r
+MingwModuleHandler::GenerateCleanTarget () const\r
 {\r
        if ( 0 == clean_files.size() )\r
                return;\r
@@ -322,7 +372,7 @@ MingwModuleHandler::GenerateCleanTarget (
 }\r
 \r
 string\r
-MingwModuleHandler::GetObjectFilenames ( const Module& module )\r
+MingwModuleHandler::GetObjectFilenames ()\r
 {\r
        const vector<File*>& files = module.non_if_data.files;\r
        if ( files.size () == 0 )\r
@@ -333,14 +383,15 @@ MingwModuleHandler::GetObjectFilenames ( const Module& module )
        {\r
                if ( objectFilenames.size () > 0 )\r
                        objectFilenames += " ";\r
-               objectFilenames += PassThruCacheDirectory (\r
-                       GetObjectFilename ( module, files[i]->name ) );\r
+               objectFilenames +=\r
+                       GetObjectFilename ( files[i]->name, NULL );\r
        }\r
        return objectFilenames;\r
 }\r
 \r
 string\r
-MingwModuleHandler::GenerateGccDefineParametersFromVector ( const vector<Define*>& defines ) const\r
+MingwModuleHandler::GenerateGccDefineParametersFromVector (\r
+       const vector<Define*>& defines ) const\r
 {\r
        string parameters;\r
        for ( size_t i = 0; i < defines.size (); i++ )\r
@@ -360,7 +411,7 @@ MingwModuleHandler::GenerateGccDefineParametersFromVector ( const vector<Define*
 }\r
 \r
 string\r
-MingwModuleHandler::GenerateGccDefineParameters ( const Module& module ) const\r
+MingwModuleHandler::GenerateGccDefineParameters () const\r
 {\r
        string parameters = GenerateGccDefineParametersFromVector ( module.project.non_if_data.defines );\r
        string s = GenerateGccDefineParametersFromVector ( module.non_if_data.defines );\r
@@ -373,8 +424,9 @@ MingwModuleHandler::GenerateGccDefineParameters ( const Module& module ) const
 }\r
 \r
 string\r
-MingwModuleHandler::ConcatenatePaths ( const string& path1,\r
-                                          const string& path2 ) const\r
+MingwModuleHandler::ConcatenatePaths (\r
+       const string& path1,\r
+       const string& path2 ) const\r
 {\r
        if ( ( path1.length () == 0 ) || ( path1 == "." ) || ( path1 == "./" ) )\r
                return path2;\r
@@ -399,7 +451,7 @@ MingwModuleHandler::GenerateGccIncludeParametersFromVector ( const vector<Includ
 }\r
 \r
 string\r
-MingwModuleHandler::GenerateGccIncludeParameters ( const Module& module ) const\r
+MingwModuleHandler::GenerateGccIncludeParameters () const\r
 {\r
        string parameters = GenerateGccIncludeParametersFromVector ( module.non_if_data.includes );\r
        string s = GenerateGccIncludeParametersFromVector ( module.project.non_if_data.includes );\r
@@ -458,7 +510,7 @@ MingwModuleHandler::GenerateImportLibraryDependenciesFromVector (
 }\r
 \r
 string\r
-MingwModuleHandler::GenerateLinkerParameters ( const Module& module ) const\r
+MingwModuleHandler::GenerateLinkerParameters () const\r
 {\r
        return GenerateLinkerParametersFromVector ( module.linkerFlags );\r
 }\r
@@ -515,29 +567,21 @@ MingwModuleHandler::GenerateMacro (
 \r
 void\r
 MingwModuleHandler::GenerateMacros (\r
-       const Module& module,\r
        const char* assignmentOperation,\r
        const IfableData& data,\r
        const vector<CompilerFlag*>* compilerFlags,\r
-       const vector<LinkerFlag*>* linkerFlags,\r
-       const string& cflags_macro,\r
-       const string& nasmflags_macro,\r
-       const string& windresflags_macro,\r
-       const string& linkerflags_macro,\r
-       const string& objs_macro,\r
-       const string& libs_macro,\r
-       const string& linkdeps_macro )\r
+       const vector<LinkerFlag*>* linkerFlags )\r
 {\r
        size_t i;\r
 \r
        if ( data.includes.size () > 0 || data.defines.size () > 0 )\r
        {\r
                GenerateMacro ( assignmentOperation,\r
-                               cflags_macro,\r
+                               cflagsMacro,\r
                                data,\r
                                compilerFlags );\r
                GenerateMacro ( assignmentOperation,\r
-                               windresflags_macro,\r
+                               windresflagsMacro,\r
                                data,\r
                                compilerFlags );\r
        }\r
@@ -550,7 +594,7 @@ MingwModuleHandler::GenerateMacros (
                        fprintf (\r
                                fMakefile,\r
                                "%s %s %s\n",\r
-                               linkerflags_macro.c_str (),\r
+                               linkerflagsMacro.c_str (),\r
                                assignmentOperation,\r
                                linkerParameters.c_str() );\r
                }\r
@@ -564,7 +608,7 @@ MingwModuleHandler::GenerateMacros (
                        fprintf (\r
                                fMakefile,\r
                                "%s %s %s\n",\r
-                               libs_macro.c_str(),\r
+                               libsMacro.c_str(),\r
                                assignmentOperation,\r
                                deps.c_str() );\r
                }\r
@@ -580,16 +624,16 @@ MingwModuleHandler::GenerateMacros (
                        {\r
                                fprintf ( fMakefile,\r
                                        "%s := %s $(%s)\n",\r
-                                       objs_macro.c_str(),\r
-                                       PassThruCacheDirectory (\r
-                                               GetObjectFilename ( module, file.name ) ).c_str (),\r
-                                       objs_macro.c_str() );\r
+                                       objectsMacro.c_str(),\r
+                                       GetObjectFilename (\r
+                                               file.name, NULL ).c_str (),\r
+                                       objectsMacro.c_str() );\r
                        }\r
                }\r
                fprintf (\r
                        fMakefile,\r
                        "%s %s",\r
-                       objs_macro.c_str (),\r
+                       objectsMacro.c_str (),\r
                        assignmentOperation );\r
                for ( i = 0; i < files.size(); i++ )\r
                {\r
@@ -599,9 +643,9 @@ MingwModuleHandler::GenerateMacros (
                                fprintf (\r
                                        fMakefile,\r
                                        "%s%s",\r
-                                       ( i%10 == 9 ? "\\\n\t" : " " ),\r
-                                       PassThruCacheDirectory (\r
-                                               GetObjectFilename ( module, file.name ) ).c_str () );\r
+                                       ( i%10 == 9 ? " \\\n\t" : " " ),\r
+                                       GetObjectFilename (\r
+                                               file.name, NULL ).c_str () );\r
                        }\r
                }\r
                fprintf ( fMakefile, "\n" );\r
@@ -623,18 +667,10 @@ MingwModuleHandler::GenerateMacros (
                                rIf.property.c_str(),\r
                                rIf.value.c_str() );\r
                        GenerateMacros (\r
-                               module,\r
                                "+=",\r
                                rIf.data,\r
                                NULL,\r
-                               NULL,\r
-                               cflags_macro,\r
-                               nasmflags_macro,\r
-                               windresflags_macro,\r
-                               linkerflags_macro,\r
-                               objs_macro,\r
-                               libs_macro,\r
-                               linkdeps_macro );\r
+                               NULL );\r
                        fprintf ( \r
                                fMakefile,\r
                                "endif\n\n" );\r
@@ -643,90 +679,16 @@ MingwModuleHandler::GenerateMacros (
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateMacros (\r
-       const Module& module,\r
-       const string& cflags_macro,\r
-       const string& nasmflags_macro,\r
-       const string& windresflags_macro,\r
-       const string& linkerflags_macro,\r
-       const string& objs_macro,\r
-       const string& libs_macro,\r
-       const string& linkdeps_macro )\r
-{\r
-       GenerateMacros (\r
-               module,\r
-               "=",\r
-               module.non_if_data,\r
-               &module.compilerFlags,\r
-               &module.linkerFlags,\r
-               cflags_macro,\r
-               nasmflags_macro,\r
-               windresflags_macro,\r
-               linkerflags_macro,\r
-               objs_macro,\r
-               libs_macro,\r
-               linkdeps_macro );\r
-\r
-       if ( module.importLibrary )\r
-       {\r
-               string s;\r
-               const vector<File*>& files = module.non_if_data.files;\r
-               for ( size_t i = 0; i < files.size (); i++ )\r
-               {\r
-                       File& file = *files[i];\r
-                       string extension = GetExtension ( file.name );\r
-                       if ( extension == ".spec" || extension == ".SPEC" )\r
-                       {\r
-                               if ( s.length () > 0 )\r
-                                       s += " ";\r
-                               s += GetSpecObjectDependencies ( file.name );\r
-                       }\r
-               }\r
-               if ( s.length () > 0 )\r
-               {\r
-                       fprintf (\r
-                               fMakefile,\r
-                               "%s += %s\n",\r
-                               linkdeps_macro.c_str(),\r
-                               s.c_str() );\r
-               }\r
-       }\r
-\r
-       fprintf (\r
-               fMakefile,\r
-               "%s += $(PROJECT_CFLAGS)\n",\r
-               cflags_macro.c_str () );\r
-\r
-       fprintf (\r
-               fMakefile,\r
-               "%s += $(PROJECT_RCFLAGS)\n",\r
-               windresflags_macro.c_str () );\r
-\r
-       fprintf (\r
-               fMakefile,\r
-               "%s_LFLAGS += $(PROJECT_LFLAGS)\n",\r
-               module.name.c_str () );\r
-\r
-       fprintf (\r
-               fMakefile,\r
-               "%s += $(%s)",\r
-               linkdeps_macro.c_str (),\r
-               libs_macro.c_str () );\r
-\r
-       fprintf ( fMakefile, "\n" );\r
-}\r
-\r
-void\r
-MingwModuleHandler::GenerateGccCommand ( const Module& module,\r
-                                         const string& sourceFilename,\r
-                                         const string& cc,\r
-                                         const string& cflagsMacro )\r
+MingwModuleHandler::GenerateGccCommand (\r
+       const string& sourceFilename,\r
+       const string& cc,\r
+       const string& cflagsMacro )\r
 {\r
        string deps = sourceFilename;\r
        if ( module.pch && use_pch )\r
                deps += " " + module.pch->header + ".gch";\r
-       string objectFilename = PassThruCacheDirectory (\r
-               GetObjectFilename ( module, sourceFilename ) );\r
+       string objectFilename = GetObjectFilename (\r
+               sourceFilename, NULL );\r
        fprintf ( fMakefile,\r
                  "%s: %s %s\n",\r
                  objectFilename.c_str (),\r
@@ -734,20 +696,19 @@ MingwModuleHandler::GenerateGccCommand ( const Module& module,
                  GetDirectory ( objectFilename ).c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_CC)\n" );\r
        fprintf ( fMakefile,\r
-                "\t%s -c %s -o $@ %s\n",\r
+                "\t%s -c $< -o $@ %s\n",\r
                 cc.c_str (),\r
-                sourceFilename.c_str (),\r
                 cflagsMacro.c_str () );\r
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateGccAssemblerCommand ( const Module& module,\r
-                                                  const string& sourceFilename,\r
-                                                  const string& cc,\r
-                                                  const string& cflagsMacro )\r
+MingwModuleHandler::GenerateGccAssemblerCommand (\r
+       const string& sourceFilename,\r
+       const string& cc,\r
+       const string& cflagsMacro )\r
 {\r
-       string objectFilename = PassThruCacheDirectory (\r
-               GetObjectFilename ( module, sourceFilename ) );\r
+       string objectFilename = GetObjectFilename (\r
+               sourceFilename, &clean_files );\r
        fprintf ( fMakefile,\r
                  "%s: %s %s\n",\r
                  objectFilename.c_str (),\r
@@ -755,19 +716,18 @@ MingwModuleHandler::GenerateGccAssemblerCommand ( const Module& module,
                  GetDirectory ( objectFilename ).c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_GAS)\n" );\r
        fprintf ( fMakefile,\r
-                 "\t%s -x assembler-with-cpp -c %s -o $@ -D__ASM__ %s\n",\r
+                 "\t%s -x assembler-with-cpp -c $< -o $@ -D__ASM__ %s\n",\r
                  cc.c_str (),\r
-                 sourceFilename.c_str (),\r
                  cflagsMacro.c_str () );\r
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateNasmCommand ( const Module& module,\r
-                                          const string& sourceFilename,\r
-                                          const string& nasmflagsMacro )\r
+MingwModuleHandler::GenerateNasmCommand (\r
+       const string& sourceFilename,\r
+       const string& nasmflagsMacro )\r
 {\r
-       string objectFilename = PassThruCacheDirectory (\r
-               GetObjectFilename ( module, sourceFilename ) );\r
+       string objectFilename = GetObjectFilename (\r
+               sourceFilename, &clean_files );\r
        fprintf ( fMakefile,\r
                  "%s: %s %s\n",\r
                  objectFilename.c_str (),\r
@@ -775,23 +735,22 @@ MingwModuleHandler::GenerateNasmCommand ( const Module& module,
                  GetDirectory ( objectFilename ).c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_NASM)\n" );\r
        fprintf ( fMakefile,\r
-                 "\t%s -f win32 %s -o $@ %s\n",\r
+                 "\t%s -f win32 $< -o $@ %s\n",\r
                  "$(Q)nasm",\r
-                 sourceFilename.c_str (),\r
                  nasmflagsMacro.c_str () );\r
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateWindresCommand ( const Module& module,\r
-                                             const string& sourceFilename,\r
-                                             const string& windresflagsMacro )\r
-{\r
-       string objectFilename = PassThruCacheDirectory ( \r
-               GetObjectFilename ( module, sourceFilename ) );\r
-       string rciFilename = ReplaceExtension ( sourceFilename,\r
-                                               ".rci" );\r
-       string resFilename = ReplaceExtension ( sourceFilename,\r
-                                               ".res" );\r
+MingwModuleHandler::GenerateWindresCommand (\r
+       const string& sourceFilename,\r
+       const string& windresflagsMacro )\r
+{\r
+       string objectFilename =\r
+               GetObjectFilename ( sourceFilename, &clean_files );\r
+       string rciFilename = ros_temp +\r
+               ReplaceExtension ( sourceFilename, ".rci" );\r
+       string resFilename = ros_temp +\r
+               ReplaceExtension ( sourceFilename, ".res" );\r
        fprintf ( fMakefile,\r
                  "%s: %s %s $(WRC_TARGET)\n",\r
                  objectFilename.c_str (),\r
@@ -804,35 +763,36 @@ MingwModuleHandler::GenerateWindresCommand ( const Module& module,
                 sourceFilename.c_str (),\r
                 rciFilename.c_str () );\r
        fprintf ( fMakefile,\r
-                "\t${wrc} ${%s} %s %s\n",\r
+                "\t$(Q)$(WRC_TARGET) ${%s} %s %s\n",\r
                 windresflagsMacro.c_str (),\r
                 rciFilename.c_str (),\r
                 resFilename.c_str () );\r
        fprintf ( fMakefile,\r
-                "\t-@${rm} %s\n",\r
+                "\t-@${rm} %s 2>$(NUL)\n",\r
                 rciFilename.c_str () );\r
        fprintf ( fMakefile,\r
-                "\t${windres} %s -o %s\n",\r
-                resFilename.c_str (),\r
-                objectFilename.c_str () );\r
+                "\t${windres} %s -o $@\n",\r
+                resFilename.c_str () );\r
        fprintf ( fMakefile,\r
-                "\t-@${rm} %s\n",\r
+                "\t-@${rm} %s 2>$(NUL)\n",\r
                 resFilename.c_str () );\r
 }\r
 \r
 void\r
 MingwModuleHandler::GenerateWinebuildCommands (\r
-       const Module& module,\r
-       const string& sourceFilename,\r
-       string_list& clean_files ) const\r
+       const string& sourceFilename )\r
 {\r
        string basename = GetBasename ( sourceFilename );\r
 \r
-       string def_file = basename + ".spec.def";\r
-       CLEAN_FILE ( def_file );\r
+       string def_file = PassThruCacheDirectory (\r
+               basename + ".spec.def",\r
+               false );\r
+       CLEAN_FILE(def_file);\r
 \r
-       string stub_file = basename + ".stubs.c";\r
-       CLEAN_FILE ( stub_file );\r
+       string stub_file = PassThruCacheDirectory (\r
+               basename + ".stubs.c",\r
+               false );\r
+       CLEAN_FILE(stub_file)\r
 \r
        fprintf ( fMakefile,\r
                  "%s: %s $(WINEBUILD_TARGET)\n",\r
@@ -841,7 +801,7 @@ MingwModuleHandler::GenerateWinebuildCommands (
        fprintf ( fMakefile, "\t$(ECHO_WINEBLD)\n" );\r
        fprintf ( fMakefile,\r
                  "\t%s --def=%s -o %s\n",\r
-                 "${winebuild}",\r
+                 "$(Q)$(WINEBUILD_TARGET)",\r
                  sourceFilename.c_str (),\r
                  def_file.c_str () );\r
 \r
@@ -852,28 +812,24 @@ MingwModuleHandler::GenerateWinebuildCommands (
        fprintf ( fMakefile, "\t$(ECHO_WINEBLD)\n" );\r
        fprintf ( fMakefile,\r
                  "\t%s --pedll=%s -o %s\n",\r
-                 "${winebuild}",\r
+                 "$(Q)$(WINEBUILD_TARGET)",\r
                  sourceFilename.c_str (),\r
                  stub_file.c_str () );\r
 }\r
 \r
 void\r
 MingwModuleHandler::GenerateCommands (\r
-       const Module& module,\r
        const string& sourceFilename,\r
        const string& cc,\r
        const string& cppc,\r
        const string& cflagsMacro,\r
        const string& nasmflagsMacro,\r
-       const string& windresflagsMacro,\r
-       string_list& clean_files )\r
+       const string& windresflagsMacro )\r
 {\r
-       CLEAN_FILE ( GetObjectFilename(module,sourceFilename) );\r
        string extension = GetExtension ( sourceFilename );\r
        if ( extension == ".c" || extension == ".C" )\r
        {\r
-               GenerateGccCommand ( module,\r
-                                    sourceFilename,\r
+               GenerateGccCommand ( sourceFilename,\r
                                     cc,\r
                                     cflagsMacro );\r
                return;\r
@@ -882,41 +838,34 @@ MingwModuleHandler::GenerateCommands (
                  extension == ".cpp" || extension == ".CPP" ||\r
                  extension == ".cxx" || extension == ".CXX" )\r
        {\r
-               GenerateGccCommand ( module,\r
-                                    sourceFilename,\r
+               GenerateGccCommand ( sourceFilename,\r
                                     cppc,\r
                                     cflagsMacro );\r
                return;\r
        }\r
        else if ( extension == ".s" || extension == ".S" )\r
        {\r
-               GenerateGccAssemblerCommand ( module,\r
-                                             sourceFilename,\r
+               GenerateGccAssemblerCommand ( sourceFilename,\r
                                              cc,\r
                                              cflagsMacro );\r
                return;\r
        }\r
        else if ( extension == ".asm" || extension == ".ASM" )\r
        {\r
-               GenerateNasmCommand ( module,\r
-                                     sourceFilename,\r
+               GenerateNasmCommand ( sourceFilename,\r
                                      nasmflagsMacro );\r
                return;\r
        }\r
        else if ( extension == ".rc" || extension == ".RC" )\r
        {\r
-               GenerateWindresCommand ( module,\r
-                                        sourceFilename,\r
+               GenerateWindresCommand ( sourceFilename,\r
                                         windresflagsMacro );\r
                return;\r
        }\r
        else if ( extension == ".spec" || extension == ".SPEC" )\r
        {\r
-               GenerateWinebuildCommands ( module,\r
-                                           sourceFilename,\r
-                                           clean_files );\r
-               GenerateGccCommand ( module,\r
-                                    GetActualSourceFilename ( sourceFilename ),\r
+               GenerateWinebuildCommands ( sourceFilename );\r
+               GenerateGccCommand ( GetActualSourceFilename ( sourceFilename ),\r
                                     cc,\r
                                     cflagsMacro );\r
                return;\r
@@ -931,29 +880,29 @@ MingwModuleHandler::GenerateCommands (
 \r
 void\r
 MingwModuleHandler::GenerateLinkerCommand (\r
-       const Module& module,\r
-       const string& target,\r
        const string& dependencies,\r
        const string& linker,\r
        const string& linkerParameters,\r
        const string& objectsMacro,\r
-       const string& libsMacro,\r
-       string_list& clean_files ) const\r
+       const string& libsMacro )\r
 {\r
+       string target ( GetTargetMacro ( module ) );\r
+       string target_folder ( GetDirectory(GetTargetFilename(module,NULL)) );\r
+\r
        fprintf ( fMakefile,\r
-               "%s: %s ${RSYM_TARGET}\n",\r
+               "%s: %s %s $(RSYM_TARGET)\n",\r
                target.c_str (),\r
-               dependencies.c_str () );\r
+               dependencies.c_str (),\r
+               target_folder.c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_LD)\n" );\r
        string targetName ( module.GetTargetName () );\r
        if ( module.importLibrary != NULL )\r
        {\r
-               static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-               string base_tmp = ros_junk + module.name + ".base.tmp";\r
+               string base_tmp = ros_temp + module.name + ".base.tmp";\r
                CLEAN_FILE ( base_tmp );\r
-               string junk_tmp = ros_junk + module.name + ".junk.tmp";\r
+               string junk_tmp = ros_temp + module.name + ".junk.tmp";\r
                CLEAN_FILE ( junk_tmp );\r
-               string temp_exp = ros_junk + module.name + ".temp.exp";\r
+               string temp_exp = ros_temp + module.name + ".temp.exp";\r
                CLEAN_FILE ( temp_exp );\r
                string def_file = module.GetBasePath () + SSEP + module.importLibrary->definition;\r
 \r
@@ -965,10 +914,10 @@ MingwModuleHandler::GenerateLinkerCommand (
                          junk_tmp.c_str (),\r
                          objectsMacro.c_str (),\r
                          libsMacro.c_str (),\r
-                         GetLinkerMacro ( module ).c_str () );\r
+                         GetLinkerMacro ().c_str () );\r
 \r
                fprintf ( fMakefile,\r
-                         "\t-@${rm} %s\n",\r
+                         "\t-@${rm} %s 2>$(NUL)\n",\r
                          junk_tmp.c_str () );\r
 \r
                string killAt = module.mangledSymbols ? "" : "--kill-at";\r
@@ -981,7 +930,7 @@ MingwModuleHandler::GenerateLinkerCommand (
                          killAt.c_str () );\r
 \r
                fprintf ( fMakefile,\r
-                         "\t-@${rm} %s\n",\r
+                         "\t-@${rm} %s 2>$(NUL)\n",\r
                          base_tmp.c_str () );\r
 \r
                fprintf ( fMakefile,\r
@@ -992,10 +941,10 @@ MingwModuleHandler::GenerateLinkerCommand (
                          target.c_str (),\r
                          objectsMacro.c_str (),\r
                          libsMacro.c_str (),\r
-                         GetLinkerMacro ( module ).c_str () );\r
+                         GetLinkerMacro ().c_str () );\r
 \r
                fprintf ( fMakefile,\r
-                         "\t-@${rm} %s\n",\r
+                         "\t-@${rm} %s 2>$(NUL)\n",\r
                          temp_exp.c_str () );\r
        }\r
        else\r
@@ -1007,26 +956,33 @@ MingwModuleHandler::GenerateLinkerCommand (
                          target.c_str (),\r
                          objectsMacro.c_str (),\r
                          libsMacro.c_str (),\r
-                         GetLinkerMacro ( module ).c_str () );\r
+                         GetLinkerMacro ().c_str () );\r
        }\r
 \r
        fprintf ( fMakefile, "\t$(ECHO_RSYM)\n" );\r
        fprintf ( fMakefile,\r
-                 "\t${rsym} %s %s\n\n",\r
-                 target.c_str (),\r
-                 target.c_str () );\r
+                 "\t$(Q)$(RSYM_TARGET) $@ $@\n\n" );\r
+}\r
+\r
+void\r
+MingwModuleHandler::GeneratePhonyTarget() const\r
+{\r
+       string targetMacro ( GetTargetMacro(module) );\r
+       fprintf ( fMakefile, ".PHONY: %s\n\n",\r
+                 targetMacro.c_str ());\r
+       fprintf ( fMakefile, "%s: %s\n",\r
+                 targetMacro.c_str (),\r
+                 GetDirectory(GetTargetFilename(module,NULL)).c_str () );\r
 }\r
 \r
 void\r
 MingwModuleHandler::GenerateObjectFileTargets (\r
-       const Module& module,\r
        const IfableData& data,\r
        const string& cc,\r
        const string& cppc,\r
        const string& cflagsMacro,\r
        const string& nasmflagsMacro,\r
-       const string& windresflagsMacro,\r
-       string_list& clean_files )\r
+       const string& windresflagsMacro )\r
 {\r
        size_t i;\r
 \r
@@ -1034,14 +990,12 @@ MingwModuleHandler::GenerateObjectFileTargets (
        for ( i = 0; i < files.size (); i++ )\r
        {\r
                string sourceFilename = files[i]->name;\r
-               GenerateCommands ( module,\r
-                                  sourceFilename,\r
+               GenerateCommands ( sourceFilename,\r
                                   cc,\r
                                   cppc,\r
                                   cflagsMacro,\r
                                   nasmflagsMacro,\r
-                                  windresflagsMacro,\r
-                                  clean_files );\r
+                                  windresflagsMacro );\r
                fprintf ( fMakefile,\r
                          "\n" );\r
        }\r
@@ -1049,26 +1003,22 @@ MingwModuleHandler::GenerateObjectFileTargets (
        const vector<If*>& ifs = data.ifs;\r
        for ( i = 0; i < ifs.size(); i++ )\r
        {\r
-               GenerateObjectFileTargets ( module,\r
-                                           ifs[i]->data,\r
+               GenerateObjectFileTargets ( ifs[i]->data,\r
                                            cc,\r
                                            cppc,\r
                                            cflagsMacro,\r
                                            nasmflagsMacro,\r
-                                           windresflagsMacro,\r
-                                           clean_files );\r
+                                           windresflagsMacro );\r
        }\r
 }\r
 \r
 void\r
 MingwModuleHandler::GenerateObjectFileTargets (\r
-       const Module& module,\r
        const string& cc,\r
        const string& cppc,\r
        const string& cflagsMacro,\r
        const string& nasmflagsMacro,\r
-       const string& windresflagsMacro,\r
-       string_list& clean_files )\r
+       const string& windresflagsMacro )\r
 {\r
        if ( module.pch )\r
        {\r
@@ -1093,23 +1043,20 @@ MingwModuleHandler::GenerateObjectFileTargets (
                }\r
        }\r
 \r
-       GenerateObjectFileTargets ( module,\r
-                                   module.non_if_data,\r
+       GenerateObjectFileTargets ( module.non_if_data,\r
                                    cc,\r
                                    cppc,\r
                                    cflagsMacro,\r
                                    nasmflagsMacro,\r
-                                   windresflagsMacro,\r
-                                   clean_files );\r
+                                   windresflagsMacro );\r
        fprintf ( fMakefile, "\n" );\r
 }\r
 \r
 string\r
-MingwModuleHandler::GenerateArchiveTarget ( const Module& module,\r
-                                            const string& ar,\r
+MingwModuleHandler::GenerateArchiveTarget ( const string& ar,\r
                                             const string& objs_macro ) const\r
 {\r
-       string archiveFilename = GetModuleArchiveFilename ( module );\r
+       string archiveFilename ( GetModuleArchiveFilename () );\r
        \r
        fprintf ( fMakefile,\r
                  "%s: %s %s\n",\r
@@ -1120,146 +1067,203 @@ MingwModuleHandler::GenerateArchiveTarget ( const Module& module,
        fprintf ( fMakefile, "\t$(ECHO_AR)\n" );\r
 \r
        fprintf ( fMakefile,\r
-                 "\t%s -rc %s %s\n\n",\r
+                 "\t%s -rc $@ %s\n\n",\r
                  ar.c_str (),\r
-                 archiveFilename.c_str (),\r
                  objs_macro.c_str ());\r
 \r
        return archiveFilename;\r
 }\r
 \r
 string\r
-MingwModuleHandler::GetCFlagsMacro ( const Module& module ) const\r
+MingwModuleHandler::GetCFlagsMacro () const\r
 {\r
        return ssprintf ( "$(%s_CFLAGS)",\r
                          module.name.c_str () );\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetObjectsMacro ( const Module& module ) const\r
+/*static*/ string\r
+MingwModuleHandler::GetObjectsMacro ( const Module& module )\r
 {\r
        return ssprintf ( "$(%s_OBJS)",\r
                          module.name.c_str () );\r
 }\r
 \r
 string\r
-MingwModuleHandler::GetLinkingDependenciesMacro ( const Module& module ) const\r
+MingwModuleHandler::GetLinkingDependenciesMacro () const\r
 {\r
        return ssprintf ( "$(%s_LINKDEPS)", module.name.c_str () );\r
 }\r
 \r
 string\r
-MingwModuleHandler::GetLibsMacro ( const Module& module ) const\r
+MingwModuleHandler::GetLibsMacro () const\r
 {\r
        return ssprintf ( "$(%s_LIBS)", module.name.c_str () );\r
 }\r
 \r
 string\r
-MingwModuleHandler::GetLinkerMacro ( const Module& module ) const\r
+MingwModuleHandler::GetLinkerMacro () const\r
 {\r
        return ssprintf ( "$(%s_LFLAGS)",\r
                          module.name.c_str () );\r
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateMacrosAndTargets (\r
-       const Module& module,\r
-       const string* cflags,\r
-       const string* nasmflags,\r
-       string_list& clean_files )\r
+MingwModuleHandler::GenerateTargetMacro ()\r
 {\r
-       string cc = ( module.host == HostTrue ? "${host_gcc}" : "${gcc}" );\r
-       string cppc = ( module.host == HostTrue ? "${host_gpp}" : "${gpp}" );\r
-       string ar = ( module.host == HostTrue ? "${host_ar}" : "${ar}" );\r
+       fprintf ( fMakefile,\r
+               "%s := %s\n",\r
+               GetTargetMacro(module,false).c_str (),\r
+               GetTargetFilename(module,NULL).c_str () );\r
+}\r
 \r
-       string cflagsMacro = ssprintf ("%s_CFLAGS", module.name.c_str ());\r
-       string nasmflagsMacro = ssprintf ("%s_NASMFLAGS", module.name.c_str ());\r
-       string windresflagsMacro = ssprintf ("%s_RCFLAGS", module.name.c_str ());\r
-       string linkerFlagsMacro = ssprintf ("%s_LFLAGS", module.name.c_str ());\r
-       string objectsMacro = ssprintf ("%s_OBJS", module.name.c_str ());\r
-       string libsMacro = ssprintf("%s_LIBS", module.name.c_str ());\r
-       string linkDepsMacro = ssprintf ("%s_LINKDEPS", module.name.c_str ());\r
-\r
-       GenerateMacros ( module,\r
-                        cflagsMacro,\r
-                        nasmflagsMacro,\r
-                        windresflagsMacro,\r
-                        linkerFlagsMacro,\r
-                        objectsMacro,\r
-                        libsMacro,\r
-                        linkDepsMacro );\r
-\r
-       if ( cflags != NULL )\r
+void\r
+MingwModuleHandler::GenerateOtherMacros ()\r
+{\r
+       cflagsMacro = ssprintf ("%s_CFLAGS", module.name.c_str ());\r
+       nasmflagsMacro = ssprintf ("%s_NASMFLAGS", module.name.c_str ());\r
+       windresflagsMacro = ssprintf ("%s_RCFLAGS", module.name.c_str ());\r
+       linkerflagsMacro = ssprintf ("%s_LFLAGS", module.name.c_str ());\r
+       objectsMacro = ssprintf ("%s_OBJS", module.name.c_str ());\r
+       libsMacro = ssprintf("%s_LIBS", module.name.c_str ());\r
+       linkDepsMacro = ssprintf ("%s_LINKDEPS", module.name.c_str ());\r
+\r
+       GenerateMacros (\r
+               "=",\r
+               module.non_if_data,\r
+               &module.compilerFlags,\r
+               &module.linkerFlags );\r
+\r
+       if ( module.importLibrary )\r
+       {\r
+               string_list s;\r
+               const vector<File*>& files = module.non_if_data.files;\r
+               for ( size_t i = 0; i < files.size (); i++ )\r
+               {\r
+                       File& file = *files[i];\r
+                       string extension = GetExtension ( file.name );\r
+                       if ( extension == ".spec" || extension == ".SPEC" )\r
+                               GetSpecObjectDependencies ( s, file.name );\r
+               }\r
+               if ( s.size () > 0 )\r
+               {\r
+                       fprintf (\r
+                               fMakefile,\r
+                               "%s +=",\r
+                               linkDepsMacro.c_str() );\r
+                       for ( size_t i = 0; i < s.size(); i++ )\r
+                               fprintf ( fMakefile,\r
+                                         " %s",\r
+                                         s[i].c_str () );\r
+                       fprintf ( fMakefile, "\n" );\r
+               }\r
+       }\r
+\r
+       fprintf (\r
+               fMakefile,\r
+               "%s += $(PROJECT_CFLAGS)\n",\r
+               cflagsMacro.c_str () );\r
+\r
+       fprintf (\r
+               fMakefile,\r
+               "%s += $(PROJECT_RCFLAGS)\n",\r
+               windresflagsMacro.c_str () );\r
+\r
+       fprintf (\r
+               fMakefile,\r
+               "%s_LFLAGS += $(PROJECT_LFLAGS)\n",\r
+               module.name.c_str () );\r
+\r
+       fprintf (\r
+               fMakefile,\r
+               "%s += $(%s)",\r
+               linkDepsMacro.c_str (),\r
+               libsMacro.c_str () );\r
+\r
+       string cflags = TypeSpecificCFlags();\r
+       if ( cflags.size() > 0 )\r
        {\r
                fprintf ( fMakefile,\r
                          "%s += %s\n\n",\r
                          cflagsMacro.c_str (),\r
-                         cflags->c_str () );\r
+                         cflags.c_str () );\r
        }\r
 \r
-       if ( nasmflags != NULL )\r
+       string nasmflags = TypeSpecificNasmFlags();\r
+       if ( nasmflags.size () > 0 )\r
        {\r
                fprintf ( fMakefile,\r
                          "%s += %s\n\n",\r
                          nasmflagsMacro.c_str (),\r
-                         nasmflags->c_str () );\r
+                         nasmflags.c_str () );\r
        }\r
 \r
-       // generate phony target for module name\r
-       fprintf ( fMakefile, ".PHONY: %s\n",\r
-               module.name.c_str () );\r
-       fprintf ( fMakefile, "%s: %s\n\n",\r
-               module.name.c_str (),\r
-               FixupTargetFilename ( module.GetPath () ).c_str () );\r
+       fprintf ( fMakefile, "\n\n" );\r
 \r
        // future references to the macros will be to get their values\r
        cflagsMacro = ssprintf ("$(%s)", cflagsMacro.c_str ());\r
        nasmflagsMacro = ssprintf ("$(%s)", nasmflagsMacro.c_str ());\r
        objectsMacro = ssprintf ("$(%s)", objectsMacro.c_str ());\r
+}\r
+\r
+void\r
+MingwModuleHandler::GenerateRules ()\r
+{\r
+       string cc = ( module.host == HostTrue ? "${host_gcc}" : "${gcc}" );\r
+       string cppc = ( module.host == HostTrue ? "${host_gpp}" : "${gpp}" );\r
+       string ar = ( module.host == HostTrue ? "${host_ar}" : "${ar}" );\r
 \r
-       string ar_target =\r
-               GenerateArchiveTarget ( module, ar, objectsMacro );\r
+       string targetMacro = GetTargetMacro ( module );\r
 \r
-       GenerateObjectFileTargets ( module,\r
-                                   cc,\r
-                                   cppc,\r
-                                   cflagsMacro,\r
-                                   nasmflagsMacro,\r
-                                   windresflagsMacro,\r
-                                   clean_files );\r
+       CLEAN_FILE ( targetMacro );\r
 \r
-       CLEAN_FILE ( ar_target );\r
-       string target = FixupTargetFilename ( module.GetPath () );\r
-       if ( target != ar_target )\r
+       // generate phony target for module name\r
+       fprintf ( fMakefile, ".PHONY: %s\n",\r
+               module.name.c_str () );\r
+       fprintf ( fMakefile, "%s: %s\n\n",\r
+               module.name.c_str (),\r
+               GetTargetMacro ( module ).c_str () );\r
+\r
+       if ( module.type != ObjectLibrary )\r
        {\r
-               CLEAN_FILE ( target );\r
+               string ar_target =\r
+                       GenerateArchiveTarget ( ar, objectsMacro );\r
+\r
+               GenerateObjectFileTargets ( cc,\r
+                                                                       cppc,\r
+                                                                       cflagsMacro,\r
+                                                                       nasmflagsMacro,\r
+                                                                       windresflagsMacro );\r
+\r
+               if ( targetMacro != ar_target )\r
+               {\r
+                       CLEAN_FILE ( ar_target );\r
+               }\r
        }\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetInvocationDependencies ( const Module& module )\r
+void\r
+MingwModuleHandler::GetInvocationDependencies (\r
+       const Module& module,\r
+       string_list& dependencies )\r
 {\r
-       string dependencies;\r
        for ( size_t i = 0; i < module.invocations.size (); i++ )\r
        {\r
                Invoke& invoke = *module.invocations[i];\r
-               if (invoke.invokeModule == &module)\r
+               if ( invoke.invokeModule == &module )\r
                        /* Protect against circular dependencies */\r
                        continue;\r
-               if ( dependencies.length () > 0 )\r
-                       dependencies += " ";\r
-               dependencies += invoke.GetTargets ();\r
+               invoke.GetTargets ( dependencies );\r
        }\r
-       return dependencies;\r
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateInvocations ( const Module& module ) const\r
+MingwModuleHandler::GenerateInvocations () const\r
 {\r
        if ( module.invocations.size () == 0 )\r
                return;\r
        \r
-       for ( size_t i = 0; i < module.invocations.size (); i++ )\r
+       size_t iend = module.invocations.size ();\r
+       for ( size_t i = 0; i < iend; i++ )\r
        {\r
                const Invoke& invoke = *module.invocations[i];\r
 \r
@@ -1270,16 +1274,29 @@ MingwModuleHandler::GenerateInvocations ( const Module& module ) const
                }\r
 \r
                string invokeTarget = module.GetInvocationTarget ( i );\r
+               string_list invoke_targets;\r
+               assert ( invoke_targets.size() );\r
+               invoke.GetTargets ( invoke_targets );\r
                fprintf ( fMakefile,\r
                          ".PHONY: %s\n\n",\r
                          invokeTarget.c_str () );\r
                fprintf ( fMakefile,\r
-                         "%s: %s\n\n",\r
-                         invokeTarget.c_str (),\r
-                         invoke.GetTargets ().c_str () );\r
+                         "%s:",\r
+                         invokeTarget.c_str () );\r
+               size_t j, jend = invoke_targets.size();\r
+               for ( j = 0; j < jend; j++ )\r
+               {\r
+                       fprintf ( fMakefile,\r
+                                 " %s",\r
+                                 invoke_targets[i].c_str () );\r
+               }\r
+               fprintf ( fMakefile, "\n\n%s", invoke_targets[0].c_str () );\r
+               for ( j = 1; j < jend; j++ )\r
+                       fprintf ( fMakefile,\r
+                                 " %s",\r
+                                 invoke_targets[i].c_str () );\r
                fprintf ( fMakefile,\r
-                         "%s: %s\n",\r
-                         invoke.GetTargets ().c_str (),\r
+                         ": %s\n",\r
                          FixupTargetFilename ( invoke.invokeModule->GetPath () ).c_str () );\r
                fprintf ( fMakefile, "\t$(ECHO_INVOKE)\n" );\r
                fprintf ( fMakefile,\r
@@ -1290,90 +1307,80 @@ MingwModuleHandler::GenerateInvocations ( const Module& module ) const
 }\r
 \r
 string\r
-MingwModuleHandler::GetPreconditionDependenciesName ( const Module& module ) const\r
+MingwModuleHandler::GetPreconditionDependenciesName () const\r
 {\r
        return module.name + "_precondition";\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetDefaultDependencies ( const Module& module ) const\r
+void\r
+MingwModuleHandler::GetDefaultDependencies (\r
+       string_list& dependencies ) const\r
 {\r
        /* Avoid circular dependency */\r
-       if ( module.type == BuildTool\r
-               || module.name == "zlib"\r
-               || module.name == "hostzlib" )\r
-               return "";\r
-       else\r
-               return "$(INIT)";\r
+       if ( module.type != BuildTool\r
+               && module.name != "zlib"\r
+               && module.name != "hostzlib" )\r
+\r
+               dependencies.push_back ( "$(INIT)" );\r
 }\r
 \r
 void\r
-MingwModuleHandler::GeneratePreconditionDependencies ( const Module& module )\r
+MingwModuleHandler::GeneratePreconditionDependencies ()\r
 {\r
-       string preconditionDependenciesName = GetPreconditionDependenciesName ( module );\r
-       string sourceFilenames = GetSourceFilenamesWithoutGeneratedFiles ( module );\r
-       string dependencies = GetDefaultDependencies ( module );\r
-       string s = GetModuleDependencies ( module );\r
-       if ( s.length () > 0 )\r
+       string preconditionDependenciesName = GetPreconditionDependenciesName ();\r
+       string_list sourceFilenames;\r
+       GetSourceFilenamesWithoutGeneratedFiles ( sourceFilenames );\r
+       string_list dependencies;\r
+       GetDefaultDependencies ( dependencies );\r
+       GetModuleDependencies ( dependencies );\r
+\r
+       GetInvocationDependencies ( module, dependencies );\r
+       \r
+       if ( dependencies.size() )\r
        {\r
-               if ( dependencies.length () > 0 )\r
-                       dependencies += " ";\r
-               dependencies += s;\r
+               fprintf ( fMakefile,\r
+                         "%s =",\r
+                         preconditionDependenciesName.c_str () );\r
+               for ( size_t i = 0; i < dependencies.size(); i++ )\r
+                       fprintf ( fMakefile,\r
+                                 " %s",\r
+                                 dependencies[i].c_str () );\r
+               fprintf ( fMakefile, "\n\n" );\r
        }\r
 \r
-       s = GetInvocationDependencies ( module );\r
-       if ( s.length () > 0 )\r
+       for ( size_t i = 0; i < sourceFilenames.size(); i++ )\r
        {\r
-               if ( dependencies.length () > 0 )\r
-                       dependencies += " ";\r
-               dependencies += s;\r
-       }\r
-       \r
-       fprintf ( fMakefile,\r
-                 "%s = %s\n\n",\r
-                 preconditionDependenciesName.c_str (),\r
-                 dependencies.c_str () );\r
-       const char* p = sourceFilenames.c_str();\r
-       const char* end = p + strlen(p);\r
-       while ( p < end )\r
-       {\r
-               const char* p2 = &p[512];\r
-               if ( p2 > end )\r
-                       p2 = end;\r
-               while ( p2 > p && !isspace(*p2) )\r
-                       --p2;\r
-               if ( p == p2 )\r
-               {\r
-                       p2 = strpbrk ( p, " \t" );\r
-                       if ( !p2 )\r
-                               p2 = end;\r
-               }\r
                fprintf ( fMakefile,\r
-                         "%.*s: ${%s}\n",\r
-                         p2-p,\r
-                         p,\r
+                         "%s: ${%s}\n",\r
+                         sourceFilenames[i].c_str(),\r
                          preconditionDependenciesName.c_str ());\r
-               p = p2;\r
-               p += strspn ( p, " \t" );\r
        }\r
        fprintf ( fMakefile, "\n" );\r
 }\r
 \r
 void\r
-MingwModuleHandler::GenerateImportLibraryTargetIfNeeded (\r
-       const Module& module,\r
-       string_list& clean_files )\r
+MingwModuleHandler::GenerateImportLibraryTargetIfNeeded ()\r
 {\r
        if ( module.importLibrary != NULL )\r
        {\r
-               string library_target = PassThruCacheDirectory ( FixupTargetFilename ( module.GetDependencyPath () ) ).c_str ();\r
-               CLEAN_FILE ( library_target );\r
+               string library_target (\r
+                       GetImportLibraryFilename ( module, &clean_files ) );\r
 \r
-               string definitionDependencies = GetDefinitionDependencies ( module );\r
-               fprintf ( fMakefile, "%s: %s %s\n",\r
-                         library_target.c_str (),\r
-                         definitionDependencies.c_str (),\r
-                         GetDirectory(library_target).c_str () );\r
+               string_list deps;\r
+               GetDefinitionDependencies ( deps );\r
+\r
+               fprintf ( fMakefile, "# IMPORT LIBRARY RULE:\n" );\r
+\r
+               fprintf ( fMakefile, "%s:",\r
+                         library_target.c_str () );\r
+\r
+               size_t i, iend = deps.size();\r
+               for ( i = 0; i < iend; i++ )\r
+                       fprintf ( fMakefile, " %s",\r
+                                 deps[i].c_str () );\r
+\r
+               fprintf ( fMakefile, " %s\n",\r
+                         GetDirectory(GetTargetFilename(module,NULL)).c_str () );\r
 \r
                fprintf ( fMakefile, "\t$(ECHO_DLLTOOL)\n" );\r
 \r
@@ -1387,20 +1394,26 @@ MingwModuleHandler::GenerateImportLibraryTargetIfNeeded (
        }\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetSpecObjectDependencies ( const string& filename ) const\r
+void\r
+MingwModuleHandler::GetSpecObjectDependencies (\r
+       string_list& dependencies,\r
+       const string& filename ) const\r
 {\r
        string basename = GetBasename ( filename );\r
-       return basename + ".spec.def" + " " + basename + ".stubs.c";\r
+       dependencies.push_back ( basename + ".spec.def" );\r
+       dependencies.push_back ( basename + ".stubs.c" );\r
 }\r
 \r
-string\r
-MingwModuleHandler::GetDefinitionDependencies ( const Module& module )\r
+void\r
+MingwModuleHandler::GetDefinitionDependencies (\r
+       string_list& dependencies ) const\r
 {\r
-       string dependencies;\r
        string dkNkmLibNoFixup = "dk/nkm/lib";\r
-       dependencies += FixupTargetFilename ( dkNkmLibNoFixup );\r
-       PassThruCacheDirectory ( dkNkmLibNoFixup + SSEP );\r
+       // TODO FIXME - verify this is the correct dependency...\r
+       // easiest way to tell is to remove it and see what breaks\r
+       /*dependencies += PassThruCacheDirectory (\r
+               FixupTargetFilename ( dkNkmLibNoFixup ),\r
+               false, NULL );*/\r
        const vector<File*>& files = module.non_if_data.files;\r
        for ( size_t i = 0; i < files.size (); i++ )\r
        {\r
@@ -1408,48 +1421,31 @@ MingwModuleHandler::GetDefinitionDependencies ( const Module& module )
                string extension = GetExtension ( file.name );\r
                if ( extension == ".spec" || extension == ".SPEC" )\r
                {\r
-                       if ( dependencies.length () > 0 )\r
-                               dependencies += " ";\r
-                       dependencies += GetSpecObjectDependencies ( file.name );\r
+                       GetSpecObjectDependencies ( dependencies, file.name );\r
                }\r
        }\r
-       return dependencies;\r
 }\r
 \r
-bool\r
-MingwModuleHandler::IsCPlusPlusModule ( const Module& module )\r
-{\r
-       return module.cplusplus;\r
-}\r
-\r
-\r
-MingwBuildToolModuleHandler::MingwBuildToolModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( BuildTool,\r
-                              backend )\r
+MingwBuildToolModuleHandler::MingwBuildToolModuleHandler ( const Module& module_ )\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwBuildToolModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwBuildToolModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateBuildToolModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateBuildToolModuleTarget ();\r
 }\r
 \r
 void\r
-MingwBuildToolModuleHandler::GenerateBuildToolModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwBuildToolModuleHandler::GenerateBuildToolModuleTarget ()\r
 {\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateMacrosAndTargets (\r
-               module,\r
-               NULL,\r
-               NULL,\r
-               clean_files );\r
+       GenerateRules ();\r
 \r
        string linker;\r
        if ( module.cplusplus )\r
@@ -1457,75 +1453,74 @@ MingwBuildToolModuleHandler::GenerateBuildToolModuleTarget ( const Module& modul
        else\r
                linker = "${host_gcc}";\r
        \r
-       fprintf ( fMakefile, "%s: %s %s\n",\r
-                 target.c_str (),\r
+       fprintf ( fMakefile, "%s: %s %s %s\n",\r
+                 targetMacro.c_str (),\r
                  objectsMacro.c_str (),\r
-                 linkDepsMacro.c_str () );\r
+                 linkDepsMacro.c_str (),\r
+                 GetDirectory(GetTargetFilename(module,NULL)).c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_LD)\n" );\r
        fprintf ( fMakefile,\r
-                 "\t%s %s -o %s %s %s\n\n",\r
+                 "\t%s %s -o $@ %s %s\n\n",\r
                  linker.c_str (),\r
-                 GetLinkerMacro ( module ).c_str (),\r
-                 target.c_str (),\r
+                 GetLinkerMacro ().c_str (),\r
                  objectsMacro.c_str (),\r
                  libsMacro.c_str () );\r
 }\r
 \r
 \r
-MingwKernelModuleHandler::MingwKernelModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( Kernel,\r
-                              backend )\r
+MingwKernelModuleHandler::MingwKernelModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwKernelModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwKernelModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateKernelModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateKernelModuleTarget ();\r
 }\r
 \r
 void\r
-MingwKernelModuleHandler::GenerateKernelModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwKernelModuleHandler::GenerateKernelModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
        string targetName ( module.GetTargetName () ); // i.e. "ntoskrnl.exe"\r
-       string target ( FixupTargetFilename (module.GetPath ()) ); // i.e. "$(ROS_INT).\ntoskrnl\ntoskrnl.exe"\r
+       string targetMacro ( GetTargetMacro (module) ); // i.e. "$(NTOSKRNL_TARGET)"\r
        string workingDirectory = GetWorkingDirectory ();\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
-       string base_tmp = ros_junk + module.name + ".base.tmp";\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
+       string base_tmp = ros_temp + module.name + ".base.tmp";\r
        CLEAN_FILE ( base_tmp );\r
-       string junk_tmp = ros_junk + module.name + ".junk.tmp";\r
+       string junk_tmp = ros_temp + module.name + ".junk.tmp";\r
        CLEAN_FILE ( junk_tmp );\r
-       string temp_exp = ros_junk + module.name + ".temp.exp";\r
+       string temp_exp = ros_temp + module.name + ".temp.exp";\r
        CLEAN_FILE ( temp_exp );\r
        string gccOptions = ssprintf ("-Wl,-T,%s" SSEP "ntoskrnl.lnk -Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -mdll",\r
                                      module.GetBasePath ().c_str (),\r
                                      module.entrypoint.c_str (),\r
                                      module.baseaddress.c_str () );\r
 \r
-       GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+       GenerateRules ();\r
 \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
-       fprintf ( fMakefile, "%s: %s %s ${RSYM_TARGET}\n",\r
-                 target.c_str (),\r
+       fprintf ( fMakefile, "%s: %s %s %s $(RSYM_TARGET)\n",\r
+                 targetMacro.c_str (),\r
                  objectsMacro.c_str (),\r
-                 linkDepsMacro.c_str () );\r
+                 linkDepsMacro.c_str (),\r
+                 GetDirectory(GetTargetFilename(module,NULL)).c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_LD)\n" );\r
        fprintf ( fMakefile,\r
                  "\t${gcc} %s %s -Wl,--base-file,%s -o %s %s %s\n",\r
-                 GetLinkerMacro ( module ).c_str (),\r
+                 GetLinkerMacro ().c_str (),\r
                  gccOptions.c_str (),\r
                  base_tmp.c_str (),\r
                  junk_tmp.c_str (),\r
                  objectsMacro.c_str (),\r
                  linkDepsMacro.c_str () );\r
        fprintf ( fMakefile,\r
-                 "\t-@${rm} %s\n",\r
+                 "\t-@${rm} %s 2>$(NUL)\n",\r
                  junk_tmp.c_str () );\r
        string killAt = module.mangledSymbols ? "" : "--kill-at";\r
        fprintf ( fMakefile,\r
@@ -1535,100 +1530,91 @@ MingwKernelModuleHandler::GenerateKernelModuleTarget ( const Module& module, str
                  temp_exp.c_str (),\r
                  killAt.c_str () );\r
        fprintf ( fMakefile,\r
-                 "\t-@${rm} %s\n",\r
+                 "\t-@${rm} %s 2>$(NUL)\n",\r
                  base_tmp.c_str () );\r
        fprintf ( fMakefile,\r
-                 "\t${gcc} %s %s -Wl,%s -o %s %s %s\n",\r
-                 GetLinkerMacro ( module ).c_str (),\r
+                 "\t${gcc} %s %s -Wl,%s -o $@ %s %s\n",\r
+                 GetLinkerMacro ().c_str (),\r
                  gccOptions.c_str (),\r
                  temp_exp.c_str (),\r
-                 target.c_str (),\r
                  objectsMacro.c_str (),\r
                  linkDepsMacro.c_str () );\r
        fprintf ( fMakefile,\r
-                 "\t-@${rm} %s\n",\r
+                 "\t-@${rm} %s 2>$(NUL)\n",\r
                  temp_exp.c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_RSYM)\n" );\r
        fprintf ( fMakefile,\r
-                     "\t${rsym} %s %s\n\n",\r
-                     target.c_str (),\r
-                     target.c_str () );\r
+                 "\t$(Q)$(RSYM_TARGET) $@ $@\n\n" );\r
 }\r
 \r
 \r
-MingwStaticLibraryModuleHandler::MingwStaticLibraryModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( StaticLibrary,\r
-                              backend )\r
+MingwStaticLibraryModuleHandler::MingwStaticLibraryModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwStaticLibraryModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwStaticLibraryModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateStaticLibraryModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateStaticLibraryModuleTarget ();\r
 }\r
 \r
 void\r
-MingwStaticLibraryModuleHandler::GenerateStaticLibraryModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwStaticLibraryModuleHandler::GenerateStaticLibraryModuleTarget ()\r
 {\r
-       GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+       GenerateRules ();\r
 }\r
 \r
 \r
-MingwObjectLibraryModuleHandler::MingwObjectLibraryModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( ObjectLibrary,\r
-                              backend )\r
+MingwObjectLibraryModuleHandler::MingwObjectLibraryModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwObjectLibraryModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwObjectLibraryModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateObjectLibraryModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateObjectLibraryModuleTarget ();\r
 }\r
 \r
 void\r
-MingwObjectLibraryModuleHandler::GenerateObjectLibraryModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwObjectLibraryModuleHandler::GenerateObjectLibraryModuleTarget ()\r
 {\r
-       GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+       GenerateRules ();\r
 }\r
 \r
 \r
-MingwKernelModeDLLModuleHandler::MingwKernelModeDLLModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( KernelModeDLL,\r
-                              backend )\r
+MingwKernelModeDLLModuleHandler::MingwKernelModeDLLModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwKernelModeDLLModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwKernelModeDLLModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateKernelModeDLLModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateKernelModeDLLModuleTarget ();\r
 }\r
 \r
 void\r
-MingwKernelModeDLLModuleHandler::GenerateKernelModeDLLModuleTarget (\r
-       const Module& module,\r
-       string_list& clean_files )\r
+MingwKernelModeDLLModuleHandler::GenerateKernelModeDLLModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ( );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies =\r
                        objectsMacro + " " + linkDepsMacro;\r
@@ -1636,61 +1622,47 @@ MingwKernelModeDLLModuleHandler::GenerateKernelModeDLLModuleTarget (
                string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -mdll",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        "${gcc}",\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str ());\r
-               fprintf ( fMakefile, "%s:\n",\r
-                         target.c_str ());\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
 \r
 \r
-MingwKernelModeDriverModuleHandler::MingwKernelModeDriverModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( KernelModeDriver,\r
-                              backend )\r
+MingwKernelModeDriverModuleHandler::MingwKernelModeDriverModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwKernelModeDriverModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwKernelModeDriverModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateKernelModeDriverModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateKernelModeDriverModuleTarget ();\r
 }\r
 \r
 \r
 void\r
-MingwKernelModeDriverModuleHandler::GenerateKernelModeDriverModuleTarget (\r
-       const Module& module,\r
-       string_list& clean_files )\r
+MingwKernelModeDriverModuleHandler::GenerateKernelModeDriverModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( PassThruCacheDirectory( FixupTargetFilename ( module.GetPath () ) ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ();\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               string cflags ( "-D__NTDRIVER__" );\r
-               GenerateMacrosAndTargets ( module,\r
-                                          &cflags,\r
-                                          NULL,\r
-                                          clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies =\r
                        objectsMacro + " " + linkDepsMacro;\r
@@ -1698,54 +1670,46 @@ MingwKernelModeDriverModuleHandler::GenerateKernelModeDriverModuleTarget (
                string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -mdll",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        "${gcc}",\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str ());\r
-               fprintf ( fMakefile, "%s:\n",\r
-                         target.c_str () );\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
 \r
 \r
-MingwNativeDLLModuleHandler::MingwNativeDLLModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( NativeDLL,\r
-                              backend )\r
+MingwNativeDLLModuleHandler::MingwNativeDLLModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwNativeDLLModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwNativeDLLModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateNativeDLLModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateNativeDLLModuleTarget ();\r
 }\r
 \r
 void\r
-MingwNativeDLLModuleHandler::GenerateNativeDLLModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwNativeDLLModuleHandler::GenerateNativeDLLModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ( );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
        \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies =\r
                        objectsMacro + " " + linkDepsMacro;\r
@@ -1753,58 +1717,46 @@ MingwNativeDLLModuleHandler::GenerateNativeDLLModuleTarget ( const Module& modul
                string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -nostdlib -mdll",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        "${gcc}",\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str ());\r
-               fprintf ( fMakefile, "%s:\n\n",\r
-                         target.c_str ());\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
 \r
 \r
-MingwNativeCUIModuleHandler::MingwNativeCUIModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( NativeCUI,\r
-                              backend )\r
+MingwNativeCUIModuleHandler::MingwNativeCUIModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwNativeCUIModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwNativeCUIModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateNativeCUIModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateNativeCUIModuleTarget ();\r
 }\r
 \r
 void\r
-MingwNativeCUIModuleHandler::GenerateNativeCUIModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwNativeCUIModuleHandler::GenerateNativeCUIModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ( );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
        \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               string cflags ( "-D__NTAPP__" );\r
-               GenerateMacrosAndTargets ( module,\r
-                                          &cflags,\r
-                                          NULL,\r
-                                          clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies =\r
                        objectsMacro + " " + linkDepsMacro;\r
@@ -1812,42 +1764,35 @@ MingwNativeCUIModuleHandler::GenerateNativeCUIModuleTarget ( const Module& modul
                string linkerParameters = ssprintf ( "-Wl,--subsystem,native -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -nostartfiles -nostdlib",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        "${gcc}",\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str ());\r
-               fprintf ( fMakefile, "%s:\n\n",\r
-                         target.c_str ());\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
 \r
 \r
-MingwWin32DLLModuleHandler::MingwWin32DLLModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( Win32DLL,\r
-                              backend )\r
+MingwWin32DLLModuleHandler::MingwWin32DLLModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwWin32DLLModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwWin32DLLModuleHandler::Process ()\r
 {\r
-       GenerateExtractWineDLLResourcesTarget ( module, clean_files );\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateWin32DLLModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateExtractWineDLLResourcesTarget ();\r
+       GenerateWin32DLLModuleTarget ();\r
 }\r
 \r
 void\r
-MingwWin32DLLModuleHandler::GenerateExtractWineDLLResourcesTarget ( const Module& module, string_list& clean_files )\r
+MingwWin32DLLModuleHandler::GenerateExtractWineDLLResourcesTarget ()\r
 {\r
        fprintf ( fMakefile, ".PHONY: %s_extractresources\n\n",\r
                  module.name.c_str () );\r
@@ -1870,20 +1815,19 @@ MingwWin32DLLModuleHandler::GenerateExtractWineDLLResourcesTarget ( const Module
 }\r
 \r
 void\r
-MingwWin32DLLModuleHandler::GenerateWin32DLLModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwWin32DLLModuleHandler::GenerateWin32DLLModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ( );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies = objectsMacro + " " + linkDepsMacro;\r
 \r
@@ -1896,54 +1840,46 @@ MingwWin32DLLModuleHandler::GenerateWin32DLLModuleTarget ( const Module& module,
                string linkerParameters = ssprintf ( "-Wl,--subsystem,console -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000 -mdll",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        linker,\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str () );\r
-               fprintf ( fMakefile, "%s:\n\n",\r
-                         target.c_str () );\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
 \r
 \r
-MingwWin32CUIModuleHandler::MingwWin32CUIModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( Win32CUI,\r
-                              backend )\r
+MingwWin32CUIModuleHandler::MingwWin32CUIModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwWin32CUIModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwWin32CUIModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateWin32CUIModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateWin32CUIModuleTarget ();\r
 }\r
 \r
 void\r
-MingwWin32CUIModuleHandler::GenerateWin32CUIModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwWin32CUIModuleHandler::GenerateWin32CUIModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ( );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies =\r
                        objectsMacro + " " + linkDepsMacro;\r
@@ -1957,54 +1893,46 @@ MingwWin32CUIModuleHandler::GenerateWin32CUIModuleTarget ( const Module& module,
                string linkerParameters = ssprintf ( "-Wl,--subsystem,console -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        linker,\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str ());\r
-               fprintf ( fMakefile, "%s:\n\n",\r
-                         target.c_str ());\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
 \r
 \r
-MingwWin32GUIModuleHandler::MingwWin32GUIModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( Win32GUI,\r
-                              backend )\r
+MingwWin32GUIModuleHandler::MingwWin32GUIModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwWin32GUIModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwWin32GUIModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateWin32GUIModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateWin32GUIModuleTarget ();\r
 }\r
 \r
 void\r
-MingwWin32GUIModuleHandler::GenerateWin32GUIModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwWin32GUIModuleHandler::GenerateWin32GUIModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ( );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies =\r
                        objectsMacro + " " + linkDepsMacro;\r
@@ -2018,106 +1946,91 @@ MingwWin32GUIModuleHandler::GenerateWin32GUIModuleTarget ( const Module& module,
                string linkerParameters = ssprintf ( "-Wl,--subsystem,windows -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        linker,\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str ());\r
-               fprintf ( fMakefile, "%s:\n\n",\r
-                         target.c_str ());\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
 \r
 \r
-MingwBootLoaderModuleHandler::MingwBootLoaderModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( BootLoader,\r
-                              backend )\r
+MingwBootLoaderModuleHandler::MingwBootLoaderModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwBootLoaderModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwBootLoaderModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateBootLoaderModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateBootLoaderModuleTarget ();\r
 }\r
 \r
 void\r
-MingwBootLoaderModuleHandler::GenerateBootLoaderModuleTarget (\r
-       const Module& module,\r
-       string_list& clean_files )\r
+MingwBootLoaderModuleHandler::GenerateBootLoaderModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
        string targetName ( module.GetTargetName () );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ();\r
-       string junk_tmp = ros_junk + module.name + ".junk.tmp";\r
+       string junk_tmp = ros_temp + module.name + ".junk.tmp";\r
        CLEAN_FILE ( junk_tmp );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+       GenerateRules ();\r
 \r
-       fprintf ( fMakefile, "%s: %s %s\n",\r
-                 target.c_str (),\r
+       fprintf ( fMakefile, "%s: %s %s %s\n",\r
+                 targetMacro.c_str (),\r
                  objectsMacro.c_str (),\r
-                 linkDepsMacro.c_str () );\r
+                 linkDepsMacro.c_str (),\r
+                 GetDirectory(GetTargetFilename(module,NULL)).c_str () );\r
 \r
        fprintf ( fMakefile, "\t$(ECHO_LD)\n" );\r
 \r
        fprintf ( fMakefile,\r
                  "\t${ld} %s -N -Ttext=0x8000 -o %s %s %s\n",\r
-                 GetLinkerMacro ( module ).c_str (),\r
+                 GetLinkerMacro ().c_str (),\r
                  junk_tmp.c_str (),\r
                  objectsMacro.c_str (),\r
                  linkDepsMacro.c_str () );\r
        fprintf ( fMakefile,\r
-                 "\t${objcopy} -O binary %s %s\n",\r
-                 junk_tmp.c_str (),\r
-                 target.c_str () );\r
+                 "\t${objcopy} -O binary %s $@\n",\r
+                 junk_tmp.c_str () );\r
        fprintf ( fMakefile,\r
-                 "\t-@${rm} %s\n",\r
+                 "\t-@${rm} %s 2>$(NUL)\n",\r
                  junk_tmp.c_str () );\r
 }\r
 \r
 \r
-MingwBootSectorModuleHandler::MingwBootSectorModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( BootSector,\r
-                              backend )\r
+MingwBootSectorModuleHandler::MingwBootSectorModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwBootSectorModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwBootSectorModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateBootSectorModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateBootSectorModuleTarget ();\r
 }\r
 \r
 void\r
-MingwBootSectorModuleHandler::GenerateBootSectorModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwBootSectorModuleHandler::GenerateBootSectorModuleTarget ()\r
 {\r
        string objectsMacro = GetObjectsMacro ( module );\r
 \r
-       string* nasmflags = new string ( "-f bin" );\r
-       GenerateMacrosAndTargets ( module,\r
-                                  NULL,\r
-                                  nasmflags,\r
-                                  clean_files );\r
+       GenerateRules ();\r
 \r
        fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                     module.name.c_str ());\r
+                 module.name.c_str ());\r
        fprintf ( fMakefile,\r
                  "%s: %s\n",\r
                  module.name.c_str (),\r
@@ -2125,31 +2038,30 @@ MingwBootSectorModuleHandler::GenerateBootSectorModuleTarget ( const Module& mod
 }\r
 \r
 \r
-MingwIsoModuleHandler::MingwIsoModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( Iso,\r
-                              backend )\r
+MingwIsoModuleHandler::MingwIsoModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwIsoModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwIsoModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateIsoModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateIsoModuleTarget ();\r
 }\r
 \r
 void\r
-MingwIsoModuleHandler::OutputBootstrapfileCopyCommands ( const string& bootcdDirectory,\r
-                                                         const Module& module )\r
+MingwIsoModuleHandler::OutputBootstrapfileCopyCommands (\r
+       const string& bootcdDirectory )\r
 {\r
        for ( size_t i = 0; i < module.project.modules.size (); i++ )\r
        {\r
                const Module& m = *module.project.modules[i];\r
                if ( m.bootstrap != NULL )\r
                {\r
-                       string targetFilenameNoFixup = bootcdDirectory + SSEP + m.bootstrap->base + SSEP + m.bootstrap->nameoncd;\r
-                       string targetFilename = PassThruCacheDirectory ( FixupTargetFilename ( targetFilenameNoFixup ) );\r
+                       string targetFilenameNoFixup ( bootcdDirectory + SSEP + m.bootstrap->base + SSEP + m.bootstrap->nameoncd );\r
+                       string targetFilename ( GetTargetMacro ( module ) );\r
                        fprintf ( fMakefile,\r
                                  "\t${cp} %s %s\n",\r
                                  m.GetPath ().c_str (),\r
@@ -2159,14 +2071,14 @@ MingwIsoModuleHandler::OutputBootstrapfileCopyCommands ( const string& bootcdDir
 }\r
 \r
 void\r
-MingwIsoModuleHandler::OutputCdfileCopyCommands ( const string& bootcdDirectory,\r
-                                                  const Module& module )\r
+MingwIsoModuleHandler::OutputCdfileCopyCommands (\r
+       const string& bootcdDirectory )\r
 {\r
        for ( size_t i = 0; i < module.project.cdfiles.size (); i++ )\r
        {\r
                const CDFile& cdfile = *module.project.cdfiles[i];\r
                string targetFilenameNoFixup = bootcdDirectory + SSEP + cdfile.base + SSEP + cdfile.nameoncd;\r
-               string targetFilename = PassThruCacheDirectory ( FixupTargetFilename ( targetFilenameNoFixup ) );\r
+               string targetFilename = GetTargetMacro(module);\r
                fprintf ( fMakefile,\r
                          "\t${cp} %s %s\n",\r
                          cdfile.GetPath ().c_str (),\r
@@ -2175,8 +2087,7 @@ MingwIsoModuleHandler::OutputCdfileCopyCommands ( const string& bootcdDirectory,
 }\r
 \r
 string\r
-MingwIsoModuleHandler::GetBootstrapCdDirectories ( const string& bootcdDirectory,\r
-                                                   const Module& module )\r
+MingwIsoModuleHandler::GetBootstrapCdDirectories ( const string& bootcdDirectory )\r
 {\r
        string directories;\r
        for ( size_t i = 0; i < module.project.modules.size (); i++ )\r
@@ -2184,46 +2095,45 @@ MingwIsoModuleHandler::GetBootstrapCdDirectories ( const string& bootcdDirectory
                const Module& m = *module.project.modules[i];\r
                if ( m.bootstrap != NULL )\r
                {\r
-                       string targetDirecctory = bootcdDirectory + SSEP + m.bootstrap->base;\r
+                       string targetDirectory ( bootcdDirectory + SSEP + m.bootstrap->base );\r
                        if ( directories.size () > 0 )\r
                                directories += " ";\r
-                       directories += PassThruCacheDirectory ( FixupTargetFilename ( targetDirecctory ) );\r
+                       directories += PassThruCacheDirectory (\r
+                               FixupTargetFilename ( targetDirectory ),\r
+                               true );\r
                }\r
        }\r
        return directories;\r
 }\r
 \r
 string\r
-MingwIsoModuleHandler::GetNonModuleCdDirectories ( const string& bootcdDirectory,\r
-                                                   const Module& module )\r
+MingwIsoModuleHandler::GetNonModuleCdDirectories ( const string& bootcdDirectory )\r
 {\r
        string directories;\r
        for ( size_t i = 0; i < module.project.cdfiles.size (); i++ )\r
        {\r
                const CDFile& cdfile = *module.project.cdfiles[i];\r
-               string targetDirecctory = bootcdDirectory + SSEP + cdfile.base;\r
+               string targetDirectory ( bootcdDirectory + SSEP + cdfile.base );\r
                if ( directories.size () > 0 )\r
                        directories += " ";\r
-               directories += PassThruCacheDirectory ( FixupTargetFilename ( targetDirecctory ) );\r
+               directories += PassThruCacheDirectory (\r
+                       FixupTargetFilename ( targetDirectory ),\r
+                       true );\r
        }\r
        return directories;\r
 }\r
 \r
 string\r
-MingwIsoModuleHandler::GetCdDirectories ( const string& bootcdDirectory,\r
-                                          const Module& module )\r
+MingwIsoModuleHandler::GetCdDirectories ( const string& bootcdDirectory )\r
 {\r
-       string directories = GetBootstrapCdDirectories ( bootcdDirectory,\r
-                                                        module );\r
-       directories += " " + GetNonModuleCdDirectories ( bootcdDirectory,\r
-                                                        module );\r
+       string directories = GetBootstrapCdDirectories ( bootcdDirectory );\r
+       directories += " " + GetNonModuleCdDirectories ( bootcdDirectory );\r
        return directories;\r
 }\r
 \r
 void\r
 MingwIsoModuleHandler::GetBootstrapCdFiles (\r
-       vector<string>& out,\r
-       const Module& module ) const\r
+       vector<string>& out ) const\r
 {\r
        for ( size_t i = 0; i < module.project.modules.size (); i++ )\r
        {\r
@@ -2235,8 +2145,7 @@ MingwIsoModuleHandler::GetBootstrapCdFiles (
 \r
 void\r
 MingwIsoModuleHandler::GetNonModuleCdFiles (\r
-       vector<string>& out,\r
-       const Module& module ) const\r
+       vector<string>& out ) const\r
 {\r
        for ( size_t i = 0; i < module.project.cdfiles.size (); i++ )\r
        {\r
@@ -2247,58 +2156,56 @@ MingwIsoModuleHandler::GetNonModuleCdFiles (
 \r
 void\r
 MingwIsoModuleHandler::GetCdFiles (\r
-       vector<string>& out,\r
-       const Module& module ) const\r
+       vector<string>& out ) const\r
 {\r
-       GetBootstrapCdFiles ( out, module );\r
-       GetNonModuleCdFiles ( out, module );\r
+       GetBootstrapCdFiles ( out );\r
+       GetNonModuleCdFiles ( out );\r
 }\r
 \r
 void\r
-MingwIsoModuleHandler::GenerateIsoModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwIsoModuleHandler::GenerateIsoModuleTarget ()\r
 {\r
        string bootcdDirectory = "cd";\r
        string isoboot = FixupTargetFilename ( "boot/freeldr/bootsect/isoboot.o" );\r
        string bootcdReactosNoFixup = bootcdDirectory + "/reactos";\r
-       string bootcdReactos = FixupTargetFilename ( bootcdReactosNoFixup );\r
-       PassThruCacheDirectory ( bootcdReactos + SSEP );\r
-       string reactosInf = FixupTargetFilename ( bootcdReactosNoFixup + "/reactos.inf" );\r
+       string bootcdReactos = PassThruCacheDirectory (\r
+               FixupTargetFilename ( bootcdReactosNoFixup ),\r
+               true );\r
+       CLEAN_FILE ( bootcdReactos );\r
+       string reactosInf = ros_temp + FixupTargetFilename ( bootcdReactosNoFixup + "/reactos.inf" );\r
        string reactosDff = NormalizeFilename ( "bootdata/packages/reactos.dff" );\r
-       string cdDirectories = GetCdDirectories ( bootcdDirectory,\r
-                                                                       module );\r
+       string cdDirectories = GetCdDirectories ( bootcdDirectory );\r
        vector<string> vCdFiles;\r
-       GetCdFiles ( vCdFiles, module );\r
+       GetCdFiles ( vCdFiles );\r
        string cdFiles = v2s ( vCdFiles, 5 );\r
 \r
        fprintf ( fMakefile, ".PHONY: %s\n\n",\r
                  module.name.c_str ());\r
        fprintf ( fMakefile,\r
-                 "%s: all %s %s %s %s ${CABMAN_TARGET} ${CDMAKE_TARGET}\n",\r
+                 "%s: all %s %s %s %s $(CABMAN_TARGET) $(CDMAKE_TARGET)\n",\r
                  module.name.c_str (),\r
                  isoboot.c_str (),\r
-                 PassThruCacheDirectory ( bootcdReactos ).c_str (),\r
+                 bootcdReactos.c_str (),\r
                  cdDirectories.c_str (),\r
                  cdFiles.c_str () );\r
        fprintf ( fMakefile, "\t$(ECHO_CABMAN)\n" );\r
        fprintf ( fMakefile,\r
-                 "\t${cabman} -C %s -L %s -I\n",\r
+                 "\t$(Q)$(CABMAN_TARGET) -C %s -L %s -I\n",\r
                  reactosDff.c_str (),\r
                  bootcdReactos.c_str () );\r
        fprintf ( fMakefile,\r
-                 "\t${cabman} -C %s -RC %s -L %s -N -P $(OUTPUT)\n",\r
+                 "\t$(Q)$(CABMAN_TARGET) -C %s -RC %s -L %s -N -P $(OUTPUT)\n",\r
                  reactosDff.c_str (),\r
                  reactosInf.c_str (),\r
                  bootcdReactos.c_str ());\r
        fprintf ( fMakefile,\r
-                 "\t-@${rm} %s\n",\r
+                 "\t-@${rm} %s 2>$(NUL)\n",\r
                  reactosInf.c_str () );\r
-       OutputBootstrapfileCopyCommands ( bootcdDirectory,\r
-                                         module );\r
-       OutputCdfileCopyCommands ( bootcdDirectory,\r
-                                  module );\r
+       OutputBootstrapfileCopyCommands ( bootcdDirectory );\r
+       OutputCdfileCopyCommands ( bootcdDirectory );\r
        fprintf ( fMakefile, "\t$(ECHO_CDMAKE)\n" );\r
        fprintf ( fMakefile,\r
-                 "\t${cdmake} -v -m -b %s %s REACTOS ReactOS.iso\n",\r
+                 "\t$(Q)$(CDMAKE_TARGET) -v -m -b %s %s REACTOS ReactOS.iso\n",\r
                  isoboot.c_str (),\r
                  bootcdDirectory.c_str () );\r
        fprintf ( fMakefile,\r
@@ -2306,35 +2213,33 @@ MingwIsoModuleHandler::GenerateIsoModuleTarget ( const Module& module, string_li
 }\r
 \r
 \r
-MingwTestModuleHandler::MingwTestModuleHandler ( MingwBackend* backend )\r
-       : MingwModuleHandler ( Test,\r
-                              backend )\r
+MingwTestModuleHandler::MingwTestModuleHandler (\r
+       const Module& module_ )\r
+\r
+       : MingwModuleHandler ( module_ )\r
 {\r
 }\r
 \r
 void\r
-MingwTestModuleHandler::Process ( const Module& module, string_list& clean_files )\r
+MingwTestModuleHandler::Process ()\r
 {\r
-       GeneratePreconditionDependencies ( module );\r
-       GenerateTestModuleTarget ( module, clean_files );\r
-       GenerateInvocations ( module );\r
+       GenerateTestModuleTarget ();\r
 }\r
 \r
 void\r
-MingwTestModuleHandler::GenerateTestModuleTarget ( const Module& module, string_list& clean_files )\r
+MingwTestModuleHandler::GenerateTestModuleTarget ()\r
 {\r
-       static string ros_junk ( "$(ROS_TEMPORARY)" );\r
-       string target ( FixupTargetFilename ( module.GetPath () ) );\r
+       string targetMacro ( GetTargetMacro (module) );\r
        string workingDirectory = GetWorkingDirectory ( );\r
        string objectsMacro = GetObjectsMacro ( module );\r
-       string linkDepsMacro = GetLinkingDependenciesMacro ( module );\r
-       string libsMacro = GetLibsMacro ( module );\r
+       string linkDepsMacro = GetLinkingDependenciesMacro ();\r
+       string libsMacro = GetLibsMacro ();\r
 \r
-       GenerateImportLibraryTargetIfNeeded ( module, clean_files );\r
+       GenerateImportLibraryTargetIfNeeded ();\r
 \r
        if ( module.non_if_data.files.size () > 0 )\r
        {\r
-               GenerateMacrosAndTargets ( module, NULL, NULL, clean_files );\r
+               GenerateRules ();\r
 \r
                string dependencies = objectsMacro + " " + linkDepsMacro;\r
 \r
@@ -2347,20 +2252,14 @@ MingwTestModuleHandler::GenerateTestModuleTarget ( const Module& module, string_
                string linkerParameters = ssprintf ( "-Wl,--subsystem,console -Wl,--entry,%s -Wl,--image-base,%s -Wl,--file-alignment,0x1000 -Wl,--section-alignment,0x1000",\r
                                                     module.entrypoint.c_str (),\r
                                                     module.baseaddress.c_str () );\r
-               GenerateLinkerCommand ( module,\r
-                                       target,\r
-                                       dependencies,\r
+               GenerateLinkerCommand ( dependencies,\r
                                        linker,\r
                                        linkerParameters,\r
                                        objectsMacro,\r
-                                       libsMacro,\r
-                                       clean_files );\r
+                                       libsMacro );\r
        }\r
        else\r
        {\r
-               fprintf ( fMakefile, ".PHONY: %s\n\n",\r
-                         target.c_str ());\r
-               fprintf ( fMakefile, "%s:\n\n",\r
-                         target.c_str ());\r
+               GeneratePhonyTarget();\r
        }\r
 }\r
index d9602b1..0e8e4ca 100644 (file)
@@ -5,10 +5,9 @@
 #include "mingw.h"\r
 \r
 class MingwBackend;\r
-       \r
+\r
 extern std::string\r
-ReplaceExtension ( const std::string& filename,\r
-                   const std::string& newExtension );\r
+GetTargetMacro ( const Module&, bool with_dollar = true );\r
 \r
 extern std::string\r
 PrefixFilename (\r
@@ -18,332 +17,309 @@ PrefixFilename (
 class MingwModuleHandler\r
 {\r
 public:\r
-       typedef std::vector<std::string> string_list;\r
-       MingwModuleHandler ( ModuleType moduletype,\r
-                            MingwBackend* backend_ );\r
+       MingwModuleHandler ( const Module& module_ );\r
        virtual ~MingwModuleHandler();\r
 \r
+       static void SetBackend ( MingwBackend* backend_ );\r
        static void SetMakefile ( FILE* f );\r
-       static MingwModuleHandler* InstanciateHandler ( const std::string& location,\r
-                                                       ModuleType moduletype_,\r
-                                                       MingwBackend* backend_ );\r
        static void SetUsePch ( bool use_pch );\r
-       static MingwModuleHandler* LookupHandler ( const std::string& location,\r
-                                                  ModuleType moduletype_ );\r
+\r
+       static std::string PassThruCacheDirectory (\r
+               const std::string &f, bool out );\r
+\r
+       static std::string GetTargetFilename (\r
+               const Module& module,\r
+               string_list* pclean_files );\r
+\r
+       static std::string\r
+       GetImportLibraryFilename (\r
+               const Module& module,\r
+               string_list* pclean_files );\r
+\r
+       void GenerateTargetMacro();\r
+       void GenerateOtherMacros();\r
+\r
+       static MingwModuleHandler* InstanciateHandler ( const Module& module_,\r
+                                                       MingwBackend* backend_ );\r
        virtual HostType DefaultHost() = 0;\r
-       virtual void Process ( const Module& module, string_list& clean_files ) = 0;\r
-       void GenerateCleanTarget ( const Module& module,\r
-                                  const string_list& clean_files ) const;\r
+       void GeneratePreconditionDependencies ();\r
+       virtual void Process () = 0;\r
+       virtual std::string TypeSpecificCFlags() { return ""; }\r
+       virtual std::string TypeSpecificNasmFlags() { return ""; }\r
+       void GenerateInvocations () const;\r
+       void GenerateCleanTarget () const;\r
 protected:\r
-       const std::string &PassThruCacheDirectory ( const std::string &f );\r
-       const std::string GetDirectoryDependency ( const std::string& file );\r
        std::string GetWorkingDirectory () const;\r
        std::string GetBasename ( const std::string& filename ) const;\r
        std::string GetActualSourceFilename ( const std::string& filename ) const;\r
-       std::string GetModuleArchiveFilename ( const Module& module ) const;\r
+       std::string GetModuleArchiveFilename () const;\r
        bool IsGeneratedFile ( const File& file ) const;\r
        std::string GetImportLibraryDependency ( const Module& importedModule );\r
-       std::string GetModuleDependencies ( const Module& module );\r
-       std::string GetAllDependencies ( const Module& module ) const;\r
-       std::string GetSourceFilenames ( const Module& module,\r
-                                        bool includeGeneratedFiles ) const;\r
-       std::string GetSourceFilenames ( const Module& module ) const;\r
-       std::string GetSourceFilenamesWithoutGeneratedFiles ( const Module& module ) const;\r
-\r
-       std::string GetObjectFilenames ( const Module& module );\r
-       void GenerateInvocations ( const Module& module ) const;\r
+       void GetModuleDependencies ( string_list& dependencies );\r
+       std::string GetAllDependencies () const;\r
+       void GetSourceFilenames ( string_list& list, bool includeGeneratedFiles = true ) const;\r
+       void GetSourceFilenamesWithoutGeneratedFiles ( string_list& list ) const;\r
+       std::string GetObjectFilename ( const std::string& sourceFilename,\r
+                                       string_list* pclean_files ) const;\r
+\r
+       std::string GetObjectFilenames ();\r
        \r
-       std::string GetPreconditionDependenciesName ( const Module& module ) const;\r
-       void GeneratePreconditionDependencies ( const Module& module );\r
-       std::string GetCFlagsMacro ( const Module& module ) const;\r
-       std::string GetObjectsMacro ( const Module& module ) const;\r
-       std::string GetLinkingDependenciesMacro ( const Module& module ) const;\r
-       std::string GetLibsMacro ( const Module& module ) const;\r
-       std::string GetLinkerMacro ( const Module& module ) const;\r
-       void GenerateLinkerCommand ( const Module& module,\r
-                                    const std::string& target,\r
-                                    const std::string& dependencies,\r
+       std::string GetPreconditionDependenciesName () const;\r
+       std::string GetCFlagsMacro () const;\r
+       static std::string GetObjectsMacro ( const Module& );\r
+       std::string GetLinkingDependenciesMacro () const;\r
+       std::string GetLibsMacro () const;\r
+       std::string GetLinkerMacro () const;\r
+       void GenerateLinkerCommand ( const std::string& dependencies,\r
                                     const std::string& linker,\r
                                     const std::string& linkerParameters,\r
                                     const std::string& objectsMacro,\r
-                                    const std::string& libsMacro,\r
-                                    string_list& clean_files ) const;\r
-       void GenerateMacrosAndTargets ( const Module& module,\r
-                                       const std::string* clags,\r
-                                       const std::string* nasmflags,\r
-                                       string_list& clean_files );\r
-       void GenerateImportLibraryTargetIfNeeded ( const Module& module, string_list& clean_files );\r
-       std::string GetDefinitionDependencies ( const Module& module );\r
-       std::string GetLinkingDependencies ( const Module& module ) const;\r
-  bool IsCPlusPlusModule ( const Module& module );\r
-  static FILE* fMakefile;\r
+                                    const std::string& libsMacro );\r
+       void GeneratePhonyTarget() const;\r
+       void GenerateRules ();\r
+       void GenerateImportLibraryTargetIfNeeded ();\r
+       void GetDefinitionDependencies ( string_list& dependencies ) const;\r
+       std::string GetLinkingDependencies () const;\r
+       static MingwBackend* backend;\r
+       static FILE* fMakefile;\r
        static bool use_pch;\r
 private:\r
        std::string ConcatenatePaths ( const std::string& path1,\r
                                       const std::string& path2 ) const;\r
        std::string GenerateGccDefineParametersFromVector ( const std::vector<Define*>& defines ) const;\r
-       std::string GenerateGccDefineParameters ( const Module& module ) const;\r
+       std::string GenerateGccDefineParameters () const;\r
        std::string GenerateGccIncludeParametersFromVector ( const std::vector<Include*>& includes ) const;\r
        std::string GenerateCompilerParametersFromVector ( const std::vector<CompilerFlag*>& compilerFlags ) const;\r
        std::string GenerateLinkerParametersFromVector ( const std::vector<LinkerFlag*>& linkerFlags ) const;\r
        std::string GenerateImportLibraryDependenciesFromVector ( const std::vector<Library*>& libraries );\r
-       std::string GenerateLinkerParameters ( const Module& module ) const;\r
+       std::string GenerateLinkerParameters () const;\r
        void GenerateMacro ( const char* assignmentOperation,\r
                             const std::string& macro,\r
                             const IfableData& data,\r
                             const std::vector<CompilerFlag*>* compilerFlags );\r
-       void GenerateMacros (\r
-                             const Module& module,\r
-                             const char* op,\r
+       void GenerateMacros ( const char* op,\r
                              const IfableData& data,\r
                              const std::vector<CompilerFlag*>* compilerFlags,\r
-                             const std::vector<LinkerFlag*>* linkerFlags,\r
-                             const std::string& cflags_macro,\r
-                             const std::string& nasmflags_macro,\r
-                             const std::string& windresflags_macro,\r
-                             const std::string& linkerflags_macro,\r
-                             const std::string& objs_macro,\r
-                             const std::string& libs_macro,\r
-                             const std::string& linkdeps_macro );\r
-       void GenerateMacros ( const Module& module,\r
-                             const std::string& cflags_macro,\r
-                             const std::string& nasmflags_macro,\r
-                             const std::string& windresflags_macro,\r
-                             const std::string& linkerflags_macro,\r
-                             const std::string& objs_macro,\r
-                             const std::string& libs_macro,\r
-                             const std::string& linkDepsMacro );\r
-       std::string GenerateGccIncludeParameters ( const Module& module ) const;\r
-       std::string GenerateGccParameters ( const Module& module ) const;\r
-       std::string GenerateNasmParameters ( const Module& module ) const;\r
-       void GenerateGccCommand ( const Module& module,\r
-                                 const std::string& sourceFilename,\r
+                             const std::vector<LinkerFlag*>* linkerFlags );\r
+       std::string GenerateGccIncludeParameters () const;\r
+       std::string GenerateGccParameters () const;\r
+       std::string GenerateNasmParameters () const;\r
+       void GenerateGccCommand ( const std::string& sourceFilename,\r
                                  const std::string& cc,\r
                                  const std::string& cflagsMacro );\r
-       void GenerateGccAssemblerCommand ( const Module& module,\r
-                                          const std::string& sourceFilename,\r
+       void GenerateGccAssemblerCommand ( const std::string& sourceFilename,\r
                                           const std::string& cc,\r
                                           const std::string& cflagsMacro );\r
-       void GenerateNasmCommand ( const Module& module,\r
-                                  const std::string& sourceFilename,\r
+       void GenerateNasmCommand ( const std::string& sourceFilename,\r
                                   const std::string& nasmflagsMacro );\r
-       void GenerateWindresCommand ( const Module& module,\r
-                                     const std::string& sourceFilename,\r
+       void GenerateWindresCommand ( const std::string& sourceFilename,\r
                                      const std::string& windresflagsMacro );\r
-       void GenerateWinebuildCommands ( const Module& module,\r
-                                        const std::string& sourceFilename,\r
-                                        string_list& clean_files ) const;\r
-       void GenerateCommands ( const Module& module,\r
-                               const std::string& sourceFilename,\r
+       void GenerateWinebuildCommands ( const std::string& sourceFilename );\r
+       void GenerateCommands ( const std::string& sourceFilename,\r
                                const std::string& cc,\r
                                const std::string& cppc,\r
                                const std::string& cflagsMacro,\r
                                const std::string& nasmflagsMacro,\r
-                               const std::string& windresflagsMacro,\r
-                               string_list& clean_files );\r
-       void GenerateObjectFileTargets ( const Module& module,\r
-                                        const IfableData& data,\r
+                               const std::string& windresflagsMacro );\r
+       void GenerateObjectFileTargets ( const IfableData& data,\r
                                         const std::string& cc,\r
                                         const std::string& cppc,\r
                                         const std::string& cflagsMacro,\r
                                         const std::string& nasmflagsMacro,\r
-                                        const std::string& windresflagsMacro,\r
-                                        string_list& clean_files );\r
-       void GenerateObjectFileTargets ( const Module& module,\r
-                                        const std::string& cc,\r
+                                        const std::string& windresflagsMacro );\r
+       void GenerateObjectFileTargets ( const std::string& cc,\r
                                         const std::string& cppc,\r
                                         const std::string& cflagsMacro,\r
                                         const std::string& nasmflagsMacro,\r
-                                        const std::string& windresflagsMacro,\r
-                                        string_list& clean_files );\r
-       std::string GenerateArchiveTarget ( const Module& module,\r
-                                           const std::string& ar,\r
+                                        const std::string& windresflagsMacro );\r
+       std::string GenerateArchiveTarget ( const std::string& ar,\r
                                            const std::string& objs_macro ) const;\r
-       std::string GetSpecObjectDependencies ( const std::string& filename ) const;\r
-       std::string GetDefaultDependencies ( const Module& module ) const;\r
-  std::string GetInvocationDependencies ( const Module& module );\r
-       MingwBackend* backend;\r
+       void GetSpecObjectDependencies ( string_list& dependencies,\r
+                                        const std::string& filename ) const;\r
+       void GetDefaultDependencies ( string_list& dependencies ) const;\r
+       void GetInvocationDependencies ( const Module& module, string_list& dependencies );\r
+\r
+public:\r
+       const Module& module;\r
+       string_list clean_files;\r
+       std::string cflagsMacro, nasmflagsMacro, windresflagsMacro,\r
+               linkerflagsMacro, objectsMacro, libsMacro, linkDepsMacro;\r
 };\r
 \r
 \r
 class MingwBuildToolModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwBuildToolModuleHandler ( MingwBackend* backend );\r
+       MingwBuildToolModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostTrue; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateBuildToolModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateBuildToolModuleTarget ();\r
 };\r
 \r
 \r
 class MingwKernelModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwKernelModuleHandler ( MingwBackend* backend );\r
+       MingwKernelModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateKernelModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateKernelModuleTarget ();\r
 };\r
 \r
 \r
 class MingwStaticLibraryModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwStaticLibraryModuleHandler ( MingwBackend* backend );\r
+       MingwStaticLibraryModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateStaticLibraryModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateStaticLibraryModuleTarget ();\r
 };\r
 \r
 \r
 class MingwObjectLibraryModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwObjectLibraryModuleHandler ( MingwBackend* backend );\r
+       MingwObjectLibraryModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateObjectLibraryModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateObjectLibraryModuleTarget ();\r
 };\r
 \r
 \r
 class MingwKernelModeDLLModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwKernelModeDLLModuleHandler ( MingwBackend* backend );\r
+       MingwKernelModeDLLModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateKernelModeDLLModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateKernelModeDLLModuleTarget ();\r
 };\r
 \r
 \r
 class MingwKernelModeDriverModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwKernelModeDriverModuleHandler ( MingwBackend* backend );\r
+       MingwKernelModeDriverModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
+       std::string TypeSpecificCFlags() { return "-D__NTDRIVER__"; }\r
 private:\r
-       void GenerateKernelModeDriverModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateKernelModeDriverModuleTarget ();\r
 };\r
 \r
 \r
 class MingwNativeDLLModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwNativeDLLModuleHandler ( MingwBackend* backend );\r
+       MingwNativeDLLModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateNativeDLLModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateNativeDLLModuleTarget ();\r
 };\r
 \r
 \r
 class MingwNativeCUIModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwNativeCUIModuleHandler ( MingwBackend* backend );\r
+       MingwNativeCUIModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
+       std::string TypeSpecificCFlags() { return "-D__NTAPP__"; }\r
 private:\r
-       void GenerateNativeCUIModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateNativeCUIModuleTarget ();\r
 };\r
 \r
 \r
 class MingwWin32DLLModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwWin32DLLModuleHandler ( MingwBackend* backend );\r
+       MingwWin32DLLModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateExtractWineDLLResourcesTarget ( const Module& module, string_list& clean_files );\r
-       void GenerateWin32DLLModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateExtractWineDLLResourcesTarget ();\r
+       void GenerateWin32DLLModuleTarget ();\r
 };\r
 \r
 \r
 class MingwWin32CUIModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwWin32CUIModuleHandler ( MingwBackend* backend );\r
+       MingwWin32CUIModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateWin32CUIModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateWin32CUIModuleTarget ();\r
 };\r
 \r
 \r
 class MingwWin32GUIModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwWin32GUIModuleHandler ( MingwBackend* backend );\r
+       MingwWin32GUIModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateWin32GUIModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateWin32GUIModuleTarget ();\r
 };\r
 \r
 \r
 class MingwBootLoaderModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwBootLoaderModuleHandler ( MingwBackend* backend );\r
+       MingwBootLoaderModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateBootLoaderModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateBootLoaderModuleTarget ();\r
 };\r
 \r
 \r
 class MingwBootSectorModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwBootSectorModuleHandler ( MingwBackend* backend );\r
+       MingwBootSectorModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
+       std::string TypeSpecificNasmFlags() { return "-f bin"; }\r
 private:\r
-       void GenerateBootSectorModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateBootSectorModuleTarget ();\r
 };\r
 \r
 \r
 class MingwIsoModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwIsoModuleHandler ( MingwBackend* backend );\r
+       MingwIsoModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateIsoModuleTarget ( const Module& module, string_list& clean_files );\r
-       std::string GetBootstrapCdDirectories ( const std::string& bootcdDirectory,\r
-                                               const Module& module );\r
-       std::string GetNonModuleCdDirectories ( const std::string& bootcdDirectory,\r
-                                               const Module& module );\r
-       std::string GetCdDirectories ( const std::string& bootcdDirectory,\r
-                                      const Module& module );\r
-       void GetBootstrapCdFiles ( std::vector<std::string>& out,\r
-                                  const Module& module ) const;\r
-       void GetNonModuleCdFiles ( std::vector<std::string>& out,\r
-                                  const Module& module ) const;\r
-       void GetCdFiles ( std::vector<std::string>& out,\r
-                         const Module& module ) const;\r
-       void OutputBootstrapfileCopyCommands ( const std::string& bootcdDirectory,\r
-                                              const Module& module );\r
-       void OutputCdfileCopyCommands ( const std::string& bootcdDirectory,\r
-                                       const Module& module );\r
+       void GenerateIsoModuleTarget ();\r
+       std::string GetBootstrapCdDirectories ( const std::string& bootcdDirectory );\r
+       std::string GetNonModuleCdDirectories ( const std::string& bootcdDirectory );\r
+       std::string GetCdDirectories ( const std::string& bootcdDirectory );\r
+       void GetBootstrapCdFiles ( std::vector<std::string>& out ) const;\r
+       void GetNonModuleCdFiles ( std::vector<std::string>& out ) const;\r
+       void GetCdFiles ( std::vector<std::string>& out ) const;\r
+       void OutputBootstrapfileCopyCommands ( const std::string& bootcdDirectory );\r
+       void OutputCdfileCopyCommands ( const std::string& bootcdDirectory );\r
 };\r
 \r
 class MingwTestModuleHandler : public MingwModuleHandler\r
 {\r
 public:\r
-       MingwTestModuleHandler ( MingwBackend* backend );\r
+       MingwTestModuleHandler ( const Module& module );\r
        virtual HostType DefaultHost() { return HostFalse; }\r
-       virtual void Process ( const Module& module, string_list& clean_files );\r
+       virtual void Process ();\r
 private:\r
-       void GenerateTestModuleTarget ( const Module& module, string_list& clean_files );\r
+       void GenerateTestModuleTarget ();\r
 };\r
 \r
 #endif /* MINGW_MODULEHANDLER_H */\r
index 5fa77ad..992dcf1 100644 (file)
@@ -19,6 +19,24 @@ FixSeparator ( const string& s )
        return s2;\r
 }\r
 \r
+string\r
+ReplaceExtension (\r
+       const string& filename,\r
+       const string& newExtension )\r
+{\r
+       size_t index = filename.find_last_of ( '/' );\r
+       if ( index == string::npos )\r
+               index = 0;\r
+       size_t index2 = filename.find_last_of ( '\\' );\r
+       if ( index2 != string::npos && index2 > index )\r
+               index = index2;\r
+       string tmp = filename.substr( index /*, filename.size() - index*/ );\r
+       size_t ext_index = tmp.find_last_of( '.' );\r
+       if ( ext_index != string::npos )\r
+               return filename.substr ( 0, index + ext_index ) + newExtension;\r
+       return filename + newExtension;\r
+}\r
+\r
 string\r
 GetSubPath (\r
        const string& location,\r
@@ -542,11 +560,12 @@ Module::GetDependencyPath () const
 {\r
        if ( HasImportLibrary () )\r
        {\r
-               return ssprintf ( "dk%cnkm%clib%clib%s.a",\r
+               return ReplaceExtension ( GetPath(), ".a" );\r
+               /*return ssprintf ( "dk%cnkm%clib%clib%s.a",\r
                                  CSEP,\r
                                  CSEP,\r
                                  CSEP,\r
-                                 name.c_str () );\r
+                                 name.c_str () );*/\r
        }\r
        else\r
                return GetPath();\r
@@ -570,23 +589,19 @@ Module::GetPathWithPrefix ( const string& prefix ) const
        return path + CSEP + prefix + GetTargetName ();\r
 }\r
 \r
-string\r
-Module::GetTargets () const\r
+void\r
+Module::GetTargets ( string_list& targets ) const\r
 {\r
        if ( invocations.size () > 0 )\r
        {\r
-               string targets ( "" );\r
                for ( size_t i = 0; i < invocations.size (); i++ )\r
                {\r
                        Invoke& invoke = *invocations[i];\r
-                       if ( targets.length () > 0 )\r
-                               targets += " ";\r
-                       targets += invoke.GetTargets ();\r
+                       invoke.GetTargets ( targets );\r
                }\r
-               return targets;\r
        }\r
        else\r
-               return GetPath ();\r
+               targets.push_back ( GetPath () );\r
 }\r
 \r
 string\r
@@ -751,23 +766,20 @@ Invoke::ProcessXMLSubElementOutput ( const XMLElement& e )
                subs_invalid = true;\r
        }\r
        if ( subs_invalid && e.subElements.size() > 0 )\r
-               throw InvalidBuildFileException ( e.location,\r
-                                                 "<%s> cannot have sub-elements",\r
-                                                 e.name.c_str() );\r
+               throw InvalidBuildFileException (\r
+                       e.location,\r
+                       "<%s> cannot have sub-elements",\r
+                       e.name.c_str() );\r
 }\r
 \r
-string\r
-Invoke::GetTargets () const\r
+void\r
+Invoke::GetTargets ( string_list& targets ) const\r
 {\r
-       string targets ( "" );\r
        for ( size_t i = 0; i < output.size (); i++ )\r
        {\r
                InvokeFile& file = *output[i];\r
-               if ( targets.length () > 0 )\r
-                       targets += " ";\r
-               targets += NormalizeFilename ( file.name );\r
+               targets.push_back ( NormalizeFilename ( file.name ) );\r
        }\r
-       return targets;\r
 }\r
 \r
 string\r
@@ -782,8 +794,7 @@ Invoke::GetParameters () const
                InvokeFile& invokeFile = *output[i];\r
                if ( invokeFile.switches.length () > 0 )\r
                {\r
-                       parameters += invokeFile.switches;\r
-                       parameters += " ";\r
+                       parameters += invokeFile.switches + " ";\r
                }\r
                parameters += invokeFile.name;\r
        }\r
index 0e73b1e..4dd7c02 100644 (file)
@@ -22,6 +22,8 @@
 #include "exception.h"\r
 #include "XML.h"\r
 \r
+typedef std::vector<std::string> string_list;\r
+\r
 #ifdef WIN32\r
 #define EXEPREFIX ""\r
 #define EXEPOSTFIX ".exe"\r
@@ -180,7 +182,7 @@ public:
        std::string GetBasePath () const;\r
        std::string GetPath () const;\r
        std::string GetPathWithPrefix ( const std::string& prefix ) const;\r
-       std::string GetTargets () const;\r
+       void GetTargets ( string_list& ) const;\r
        std::string GetInvocationTarget ( const int index ) const;\r
        bool HasFileWithExtension ( const IfableData&, const std::string& extension ) const;\r
        void InvokeModule () const;\r
@@ -278,7 +280,7 @@ public:
                 const Module& _module );\r
 \r
        void ProcessXML();\r
-       std::string GetTargets () const;\r
+       void GetTargets ( string_list& targets ) const;\r
        std::string GetParameters () const;\r
 private:\r
        void ProcessXMLSubElement ( const XMLElement& e );\r
@@ -562,6 +564,11 @@ public:
 extern std::string\r
 FixSeparator ( const std::string& s );\r
 \r
+extern std::string\r
+ReplaceExtension (\r
+       const std::string& filename,\r
+       const std::string& newExtension );\r
+\r
 extern std::string\r
 GetSubPath (\r
        const std::string& location,\r
index 9c2f371..d82505d 100644 (file)
-RBUILD_BASE = $(TOOLS_BASE)$(SEP)rbuild\r
+RBUILD_BASE = $(TOOLS_BASE_)rbuild\r
+RBUILD_BASE_ = $(RBUILD_BASE)$(SEP)\r
+RBUILD_INT = $(INTERMEDIATE_)$(RBUILD_BASE)\r
+RBUILD_INT_ = $(RBUILD_INT)$(SEP)\r
+RBUILD_OUT = $(OUTPUT_)$(RBUILD_BASE)\r
+RBUILD_OUT_ = $(RBUILD_OUT)$(SEP)\r
+\r
+$(RBUILD_INT): $(TOOLS_INT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
+\r
+ifneq ($(INTERMEDIATE),$(OUTPUT))\r
+$(RBUILD_OUT): $(TOOLS_OUT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
+endif\r
+\r
+\r
+RBUILD_BACKEND_BASE = $(RBUILD_BASE_)backend\r
+RBUILD_BACKEND_BASE_ = $(RBUILD_BACKEND_BASE)$(SEP)\r
+RBUILD_BACKEND_INT = $(INTERMEDIATE_)$(RBUILD_BACKEND_BASE)\r
+RBUILD_BACKEND_INT_ = $(RBUILD_BACKEND_INT)$(SEP)\r
+RBUILD_BACKEND_OUT = $(OUTPUT)$(RBUILD_BACKEND_BASE)\r
+RBUILD_BACKEND_OUT_ = $(RBUILD_BACKEND_OUT)$(SEP)\r
+\r
+$(RBUILD_BACKEND_INT): $(RBUILD_INT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
+\r
+ifneq ($(INTERMEDIATE),$(OUTPUT))\r
+$(RBUILD_BACKEND_OUT): $(RBUILD_OUT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
+endif\r
+\r
+\r
+RBUILD_MINGW_BASE = $(RBUILD_BACKEND_BASE_)mingw\r
+RBUILD_MINGW_BASE_ = $(RBUILD_MINGW_BASE)$(SEP)\r
+RBUILD_MINGW_INT = $(INTERMEDIATE_)$(RBUILD_MINGW_BASE)\r
+RBUILD_MINGW_INT_ = $(RBUILD_MINGW_INT)$(SEP)\r
+RBUILD_MINGW_OUT = $(OUTPUT)$(RBUILD_MINGW_BASE)\r
+RBUILD_MINGW_OUT_ = $(RBUILD_MINGW_OUT)$(SEP)\r
+\r
+$(RBUILD_MINGW_INT): $(RBUILD_BACKEND_INT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
+\r
+ifneq ($(INTERMEDIATE),$(OUTPUT))\r
+$(RBUILD_MINGW_OUT): $(RBUILD_BACKEND_OUT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
+endif\r
+\r
+\r
+RBUILD_DEVCPP_BASE = $(RBUILD_BACKEND_BASE_)devcpp\r
+RBUILD_DEVCPP_BASE_ = $(RBUILD_DEVCPP_BASE)$(SEP)\r
+RBUILD_DEVCPP_INT = $(INTERMEDIATE_)$(RBUILD_DEVCPP_BASE)\r
+RBUILD_DEVCPP_INT_ = $(RBUILD_DEVCPP_INT)$(SEP)\r
+RBUILD_DEVCPP_OUT = $(OUTPUT)$(RBUILD_DEVCPP_BASE)\r
+RBUILD_DEVCPP_OUT_ = $(RBUILD_DEVCPP_OUT)$(SEP)\r
 \r
-RBUILD_BASE_DIR = $(INTERMEDIATE)$(RBUILD_BASE)\r
-RBUILD_BASE_DIR_EXISTS = $(RBUILD_BASE_DIR)$(SEP)$(EXISTS)\r
+$(RBUILD_DEVCPP_INT): $(RBUILD_BACKEND_INT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
 \r
-$(RBUILD_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)\r
+ifneq ($(INTERMEDIATE),$(OUTPUT))\r
+$(RBUILD_DEVCPP_OUT): $(RBUILD_BACKEND_OUT)\r
        $(ECHO_MKDIR)\r
-       ${mkdir} $(RBUILD_BASE_DIR)\r
-       @echo . >$@\r
+       ${mkdir} $@\r
+endif\r
+\r
 \r
 RBUILD_TARGET = \\r
-       $(RBUILD_BASE_DIR)$(SEP)rbuild$(EXEPOSTFIX)\r
+       $(EXEPREFIX)$(RBUILD_OUT_)rbuild$(EXEPOSTFIX)\r
 \r
 RBUILD_TEST_TARGET = \\r
-       $(RBUILD_BASE_DIR)$(SEP)rbuild_test$(EXEPOSTFIX)\r
+       $(EXEPREFIX)$(RBUILD_OUT_)rbuild_test$(EXEPOSTFIX)\r
 \r
-RBUILD_BACKEND_MINGW_BASE_SOURCES = \\r
-       backend$(SEP)mingw$(SEP)mingw.cpp \\r
-       backend$(SEP)mingw$(SEP)modulehandler.cpp\r
+RBUILD_BACKEND_MINGW_BASE_SOURCES = $(addprefix $(RBUILD_MINGW_BASE_), \\r
+       mingw.cpp \\r
+       modulehandler.cpp \\r
+       )\r
 \r
-RBUILD_BACKEND_DEVCPP_BASE_SOURCES = \\r
-       backend$(SEP)devcpp$(SEP)devcpp.cpp\r
+RBUILD_BACKEND_DEVCPP_BASE_SOURCES = $(addprefix $(RBUILD_DEVCPP_BASE_), \\r
+       devcpp.cpp \\r
+       )\r
 \r
-RBUILD_BACKEND_BASE_SOURCES = \\r
+RBUILD_BACKEND_SOURCES = \\r
        $(RBUILD_BACKEND_MINGW_BASE_SOURCES) \\r
        $(RBUILD_BACKEND_DEVCPP_BASE_SOURCES) \\r
-       backend$(SEP)backend.cpp\r
-\r
-RBUILD_BASE_SOURCES = \\r
-       $(RBUILD_BACKEND_BASE_SOURCES) \\r
-       automaticdependency.cpp \\r
-       bootstrap.cpp \\r
-       cdfile.cpp \\r
-       compilerflag.cpp \\r
-       define.cpp \\r
-       exception.cpp \\r
-       include.cpp \\r
-       linkerflag.cpp \\r
-       module.cpp \\r
-       project.cpp \\r
-       ssprintf.cpp \\r
-       stubbedcomponent.cpp \\r
-       XML.cpp\r
+       $(RBUILD_BACKEND_BASE_)backend.cpp\r
 \r
 RBUILD_COMMON_SOURCES = \\r
-       $(addprefix $(RBUILD_BASE)$(SEP), $(RBUILD_BASE_SOURCES)) \\r
+       $(RBUILD_BACKEND_SOURCES) \\r
+       $(addprefix $(RBUILD_BASE_), \\r
+               automaticdependency.cpp \\r
+               bootstrap.cpp \\r
+               cdfile.cpp \\r
+               compilerflag.cpp \\r
+               define.cpp \\r
+               exception.cpp \\r
+               include.cpp \\r
+               linkerflag.cpp \\r
+               module.cpp \\r
+               project.cpp \\r
+               ssprintf.cpp \\r
+               stubbedcomponent.cpp \\r
+               XML.cpp \\r
+               )\r
 \r
 RBUILD_SPECIAL_SOURCES = \\r
-       $(RBUILD_BASE)$(SEP)rbuild.cpp\r
+       $(RBUILD_BASE_)rbuild.cpp\r
 \r
 RBUILD_SOURCES = \\r
        $(RBUILD_COMMON_SOURCES) \\r
        $(RBUILD_SPECIAL_SOURCES)\r
 \r
 RBUILD_COMMON_OBJECTS = \\r
-       $(addprefix $(ROS_INTERMEDIATE), $(RBUILD_COMMON_SOURCES:.cpp=.o))\r
+       $(addprefix $(INTERMEDIATE_), $(RBUILD_COMMON_SOURCES:.cpp=.o))\r
 \r
 RBUILD_SPECIAL_OBJECTS = \\r
-       $(addprefix $(ROS_INTERMEDIATE), $(RBUILD_SPECIAL_SOURCES:.cpp=.o))\r
+       $(addprefix $(INTERMEDIATE_), $(RBUILD_SPECIAL_SOURCES:.cpp=.o))\r
 \r
 RBUILD_OBJECTS = \\r
        $(RBUILD_COMMON_OBJECTS) \\r
@@ -76,15 +139,15 @@ RBUILD_TESTS = \
        tests$(SEP)symboltest.cpp\r
 \r
 RBUILD_TEST_SPECIAL_SOURCES = \\r
-       $(addprefix $(RBUILD_BASE)$(SEP), $(RBUILD_TESTS)) \\r
-       $(RBUILD_BASE)$(SEP)tests$(SEP)alltests.cpp\r
+       $(addprefix $(RBUILD_BASE_), $(RBUILD_TESTS)) \\r
+       $(RBUILD_BASE_)tests$(SEP)alltests.cpp\r
 \r
 RBUILD_TEST_SOURCES = \\r
        $(RBUILD_COMMON_SOURCES) \\r
        $(RBUILD_TEST_SPECIAL_SOURCES)\r
 \r
 RBUILD_TEST_SPECIAL_OBJECTS = \\r
-       $(addprefix $(ROS_INTERMEDIATE), $(RBUILD_TEST_SPECIAL_SOURCES:.cpp=.o))\r
+       $(addprefix $(INTERMEDIATE_), $(RBUILD_TEST_SPECIAL_SOURCES:.cpp=.o))\r
 \r
 RBUILD_TEST_OBJECTS = \\r
        $(RBUILD_COMMON_OBJECTS) \\r
@@ -97,26 +160,98 @@ RBUILD_HOST_LFLAGS = -g
 .PHONY: rbuild\r
 rbuild: $(RBUILD_TARGET)\r
 \r
-$(RBUILD_TARGET): $(RBUILD_OBJECTS) $(RBUILD_BASE_DIR_EXISTS)\r
+$(RBUILD_TARGET): $(RBUILD_OBJECTS) $(RBUILD_OUT)\r
        $(ECHO_LD)\r
-       ${host_gpp} $(RBUILD_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $(RBUILD_TARGET)\r
+       ${host_gpp} $(RBUILD_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $@\r
 \r
-$(RBUILD_COMMON_OBJECTS): %.o: %.cpp\r
+$(RBUILD_INT_)automaticdependency.o: $(RBUILD_BASE_)automaticdependency.cpp $(RBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
 \r
-$(RBUILD_SPECIAL_OBJECTS): %.o: %.cpp\r
+$(RBUILD_INT_)bootstrap.o: $(RBUILD_BASE_)bootstrap.cpp $(RBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
 \r
-$(RBUILD_TEST_TARGET): $(RBUILD_TEST_OBJECTS) $(RBUILD_BASE_DIR_EXISTS)\r
-       $(ECHO_LD)\r
-       ${host_gpp} $(RBUILD_TEST_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $(RBUILD_TEST_TARGET)\r
+$(RBUILD_INT_)cdfile.o: $(RBUILD_BASE_)cdfile.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)compilerflag.o: $(RBUILD_BASE_)compilerflag.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)define.o: $(RBUILD_BASE_)define.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)exception.o: $(RBUILD_BASE_)exception.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)include.o: $(RBUILD_BASE_)include.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
 \r
-$(RBUILD_TEST_SPECIAL_OBJECTS): %.o: %.cpp\r
+$(RBUILD_INT_)linkerflag.o: $(RBUILD_BASE_)linkerflag.cpp $(RBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
 \r
+$(RBUILD_INT_)module.o: $(RBUILD_BASE_)module.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)project.o: $(RBUILD_BASE_)project.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)rbuild.o: $(RBUILD_BASE_)rbuild.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)ssprintf.o: $(RBUILD_BASE_)ssprintf.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)stubbedcomponent.o: $(RBUILD_BASE_)stubbedcomponent.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_INT_)XML.o: $(RBUILD_BASE_)XML.cpp $(RBUILD_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_BACKEND_INT_)backend.o: $(RBUILD_BACKEND_BASE_)backend.cpp $(RBUILD_BACKEND_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_MINGW_INT_)mingw.o: $(RBUILD_MINGW_BASE_)mingw.cpp $(RBUILD_MINGW_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_MINGW_INT_)modulehandler.o: $(RBUILD_MINGW_BASE_)modulehandler.cpp $(RBUILD_MINGW_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+$(RBUILD_DEVCPP_INT_)devcpp.o: $(RBUILD_DEVCPP_BASE_)devcpp.cpp $(RBUILD_DEVCPP_INT)\r
+       $(ECHO_CC)\r
+       ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+#$(RBUILD_COMMON_OBJECTS): %.o: %.cpp $(RBUILD_INT)\r
+#      $(ECHO_CC)\r
+#      ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+#$(RBUILD_SPECIAL_OBJECTS): %.o: %.cpp $(RBUILD_INT)\r
+#      $(ECHO_CC)\r
+#      ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
+#$(RBUILD_TEST_TARGET): $(RBUILD_TEST_OBJECTS) $(RBUILD_OUT)\r
+#      $(ECHO_LD)\r
+#      ${host_gpp} $(RBUILD_TEST_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $@\r
+\r
+#$(RBUILD_TEST_SPECIAL_OBJECTS): %.o: %.cpp $(RBUILD_INT)\r
+#      $(ECHO_CC)\r
+#      ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@\r
+\r
 \r
 \r
 .PHONY: rbuild_test\r
index 766ae82..faf972f 100644 (file)
@@ -1,60 +1,36 @@
-RMKDIR_BASE = tools
-
-RMKDIR_BASE_DIR = $(INTERMEDIATE)
-RMKDIR_BASE_DIR_EXISTS = $(RMKDIR_BASE_DIR)$(EXISTS)
-
-RMKDIR_TARGET = \
-       $(RMKDIR_BASE_DIR)rmkdir$(EXEPOSTFIX)
-
-RMKDIR_SOURCES = \
-       $(RMKDIR_BASE)$(SEP)rmkdir.c
-
-RMKDIR_OBJECTS = \
-       $(RMKDIR_BASE_DIR)rmkdir.o
-
-RMKDIR_HOST_CFLAGS = -g -Werror -Wall
-
-RMKDIR_HOST_LFLAGS = -g
-
-.PHONY: rmkdir
-rmkdir: $(RMKDIR_TARGET)
-
-$(RMKDIR_TARGET): $(RMKDIR_OBJECTS)
-       $(ECHO_LD)
-       ${host_gcc} $(RMKDIR_OBJECTS) $(RMKDIR_HOST_LFLAGS) -o $@
-
-$(RMKDIR_BASE_DIR)rmkdir.o: $(RMKDIR_BASE)$(SEP)rmkdir.c $(RMKDIR_BASE_DIR_EXISTS)
-       $(ECHO_CC)
-       ${host_gcc} $(RMKDIR_HOST_CFLAGS) -c $< -o $@
-
-.PHONY: rmkdir_clean
-rmkdir_clean:
-       -@$(rm) $(RMKDIR_TARGET) $(RMKDIR_OBJECTS) 2>$(NUL)
-clean: rmkdir_clean
-
-
 TOOLS_BASE = tools
-TOOLS_BASE_DIR = $(INTERMEDIATE)$(TOOLS_BASE)
-TOOLS_BASE_DIR_EXISTS = $(TOOLS_BASE_DIR)$(EXISTS)
-
-$(TOOLS_BASE_DIR_EXISTS): $(INTERMEDIATE_EXISTS) $(RMKDIR_TARGET)
-       ${mkdir} $(TOOLS_BASE_DIR)
-       @echo . >$@
-
+TOOLS_BASE_ = $(TOOLS_BASE)$(SEP)
+TOOLS_INT = $(INTERMEDIATE_)$(TOOLS_BASE)
+TOOLS_INT_ = $(TOOLS_INT)$(SEP)
+TOOLS_OUT = $(OUTPUT_)$(TOOLS_BASE)
+TOOLS_OUT_ = $(TOOLS_OUT)$(SEP)
+
+$(TOOLS_INT): $(INTERMEDIATE)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
+
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(TOOLS_OUT): $(OUTPUT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
+endif
 
 RSYM_BASE = $(TOOLS_BASE)
+RSYM_BASE_ = $(RSYM_BASE)$(SEP)
 
-RSYM_BASE_DIR = $(INTERMEDIATE)$(RSYM_BASE)
-RSYM_BASE_DIR_EXISTS = $(RSYM_BASE_DIR)$(EXISTS)
+RSYM_INT = $(INTERMEDIATE_)$(RSYM_BASE)
+RSYM_INT_ = $(RSYM_INT)$(SEP)
+RSYM_OUT = $(OUTPUT_)$(RSYM_BASE)
+RSYM_OUT_ = $(RSYM_OUT)$(SEP)
 
 RSYM_TARGET = \
-       $(RSYM_BASE_DIR)$(SEP)rsym$(EXEPOSTFIX)
+       $(EXEPREFIX)$(RSYM_OUT_)rsym$(EXEPOSTFIX)
 
 RSYM_SOURCES = \
-       $(RSYM_BASE)$(SEP)rsym.c
+       $(RSYM_BASE_)rsym.c
 
 RSYM_OBJECTS = \
-       $(RSYM_SOURCES:.c=.o)
+       $(addprefix $(INTERMEDIATE_), $(RSYM_SOURCES:.c=.o))
 
 RSYM_HOST_CFLAGS = -g -Werror -Wall
 
@@ -63,11 +39,11 @@ RSYM_HOST_LFLAGS = -g
 .PHONY: rsym
 rsym: $(RSYM_TARGET)
 
-$(RSYM_TARGET): $(RSYM_OBJECTS)
+$(RSYM_TARGET): $(RSYM_OBJECTS) $(RSYM_OUT)
        $(ECHO_LD)
        ${host_gcc} $(RSYM_OBJECTS) $(RSYM_HOST_LFLAGS) -o $@
 
-$(RSYM_OBJECTS): %.o : %.c $(RSYM_BASE_DIR_EXISTS)
+$(RSYM_INT_)rsym.o: $(RSYM_BASE_)rsym.c $(RSYM_INT)
        $(ECHO_CC)
        ${host_gcc} $(RSYM_HOST_CFLAGS) -c $< -o $@
 
@@ -79,6 +55,7 @@ clean: rsym_clean
 
 include tools/bin2res/bin2res.mak
 include tools/buildno/buildno.mak
+include tools/cabman/cabman.mak
 include tools/cdmake/cdmake.mak
 include tools/nci/nci.mak
 include tools/rbuild/rbuild.mak
@@ -87,7 +64,3 @@ include tools/winebuild/winebuild.mak
 include tools/wmc/wmc.mak
 include tools/wpp/wpp.mak
 include tools/wrc/wrc.mak
-include lib/zlib/zlib.mak
-
-# cabman must come after zlib
-include tools/cabman/cabman.mak
index 473b9b3..b5d7ed2 100644 (file)
@@ -1,15 +1,22 @@
-UNICODE_BASE = $(TOOLS_BASE)$(SEP)unicode
-
-UNICODE_BASE_DIR = $(INTERMEDIATE)$(UNICODE_BASE)
-UNICODE_BASE_DIR_EXISTS = $(UNICODE_BASE_DIR)$(SEP)$(EXISTS)
+UNICODE_BASE = $(TOOLS_BASE_)unicode
+UNICODE_BASE_ = $(UNICODE_BASE)$(SEP)
+UNICODE_INT = $(INTERMEDIATE_)$(UNICODE_BASE)
+UNICODE_INT_ = $(UNICODE_INT)$(SEP)
+UNICODE_OUT = $(OUTPUT_)$(UNICODE_BASE)
+UNICODE_OUT_ = $(UNICODE_OUT)$(SEP)
+
+$(UNICODE_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(UNICODE_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(UNICODE_OUT): $(TOOLS_OUT)
        $(ECHO_MKDIR)
-       ${mkdir} $(UNICODE_BASE_DIR)
-       @echo . >$(UNICODE_BASE_DIR_EXISTS)
+       ${mkdir} $@
+endif
 
 UNICODE_TARGET = \
-       $(UNICODE_BASE_DIR)$(SEP)libunicode.a
+       $(UNICODE_OUT_)libunicode.a
 
 UNICODE_CODEPAGES = \
        037 \
@@ -73,18 +80,19 @@ UNICODE_CODEPAGES = \
        28605 \
        28606
 
-UNICODE_SOURCES = \
-       $(UNICODE_BASE)$(SEP)casemap.c \
-       $(UNICODE_BASE)$(SEP)compose.c \
-       $(UNICODE_BASE)$(SEP)cptable.c \
-       $(UNICODE_BASE)$(SEP)mbtowc.c \
-       $(UNICODE_BASE)$(SEP)string.c \
-       $(UNICODE_BASE)$(SEP)wctomb.c \
-       $(UNICODE_BASE)$(SEP)wctype.c \
-  $(addprefix $(UNICODE_BASE)$(SEP), $(UNICODE_CODEPAGES:%=c_%.o))
+UNICODE_SOURCES = $(addprefix $(UNICODE_BASE_), \
+       casemap.c \
+       compose.c \
+       cptable.c \
+       mbtowc.c \
+       string.c \
+       wctomb.c \
+       wctype.c \
+       $(UNICODE_CODEPAGES:%=c_%.o) \
+       )
 
 UNICODE_OBJECTS = \
-  $(addprefix $(INTERMEDIATE), $(UNICODE_SOURCES:.c=.o))
+  $(addprefix $(INTERMEDIATE_), $(UNICODE_SOURCES:.c=.o))
 
 UNICODE_HOST_CFLAGS = \
        -D__USE_W32API -DWINVER=0x501 -DWINE_UNICODE_API= \
@@ -94,275 +102,275 @@ UNICODE_HOST_CFLAGS = \
 .PHONY: unicode
 unicode: $(UNICODE_TARGET)
 
-$(UNICODE_TARGET): $(UNICODE_OBJECTS)
+$(UNICODE_TARGET): $(UNICODE_OBJECTS) $(UNICODE_OUT)
        $(ECHO_AR)
        ${host_ar} -rc $@ $(UNICODE_OBJECTS)
 
-$(UNICODE_BASE_DIR)$(SEP)casemap.o: $(UNICODE_BASE)$(SEP)casemap.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)casemap.o: $(UNICODE_BASE_)casemap.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)compose.o: $(UNICODE_BASE)$(SEP)compose.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)compose.o: $(UNICODE_BASE_)compose.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)cptable.o: $(UNICODE_BASE)$(SEP)cptable.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)cptable.o: $(UNICODE_BASE_)cptable.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)mbtowc.o: $(UNICODE_BASE)$(SEP)mbtowc.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)mbtowc.o: $(UNICODE_BASE_)mbtowc.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)string.o: $(UNICODE_BASE)$(SEP)string.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)string.o: $(UNICODE_BASE_)string.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)wctomb.o: $(UNICODE_BASE)$(SEP)wctomb.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)wctomb.o: $(UNICODE_BASE_)wctomb.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)wctype.o: $(UNICODE_BASE)$(SEP)wctype.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)wctype.o: $(UNICODE_BASE_)wctype.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_037.o: $(UNICODE_BASE)$(SEP)c_037.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_037.o: $(UNICODE_BASE_)c_037.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_424.o: $(UNICODE_BASE)$(SEP)c_424.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_424.o: $(UNICODE_BASE_)c_424.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_437.o: $(UNICODE_BASE)$(SEP)c_437.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_437.o: $(UNICODE_BASE_)c_437.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_500.o: $(UNICODE_BASE)$(SEP)c_500.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_500.o: $(UNICODE_BASE_)c_500.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_737.o: $(UNICODE_BASE)$(SEP)c_737.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_737.o: $(UNICODE_BASE_)c_737.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_775.o: $(UNICODE_BASE)$(SEP)c_775.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_775.o: $(UNICODE_BASE_)c_775.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_850.o: $(UNICODE_BASE)$(SEP)c_850.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_850.o: $(UNICODE_BASE_)c_850.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_852.o: $(UNICODE_BASE)$(SEP)c_852.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_852.o: $(UNICODE_BASE_)c_852.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_855.o: $(UNICODE_BASE)$(SEP)c_855.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_855.o: $(UNICODE_BASE_)c_855.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_856.o: $(UNICODE_BASE)$(SEP)c_856.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_856.o: $(UNICODE_BASE_)c_856.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_857.o: $(UNICODE_BASE)$(SEP)c_857.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_857.o: $(UNICODE_BASE_)c_857.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_860.o: $(UNICODE_BASE)$(SEP)c_860.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_860.o: $(UNICODE_BASE_)c_860.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_861.o: $(UNICODE_BASE)$(SEP)c_861.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_861.o: $(UNICODE_BASE_)c_861.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_862.o: $(UNICODE_BASE)$(SEP)c_862.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_862.o: $(UNICODE_BASE_)c_862.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_863.o: $(UNICODE_BASE)$(SEP)c_863.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_863.o: $(UNICODE_BASE_)c_863.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_864.o: $(UNICODE_BASE)$(SEP)c_864.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_864.o: $(UNICODE_BASE_)c_864.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_865.o: $(UNICODE_BASE)$(SEP)c_865.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_865.o: $(UNICODE_BASE_)c_865.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_866.o: $(UNICODE_BASE)$(SEP)c_866.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_866.o: $(UNICODE_BASE_)c_866.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_869.o: $(UNICODE_BASE)$(SEP)c_869.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_869.o: $(UNICODE_BASE_)c_869.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_874.o: $(UNICODE_BASE)$(SEP)c_874.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_874.o: $(UNICODE_BASE_)c_874.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_875.o: $(UNICODE_BASE)$(SEP)c_875.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_875.o: $(UNICODE_BASE_)c_875.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_878.o: $(UNICODE_BASE)$(SEP)c_878.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_878.o: $(UNICODE_BASE_)c_878.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_932.o: $(UNICODE_BASE)$(SEP)c_932.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_932.o: $(UNICODE_BASE_)c_932.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_936.o: $(UNICODE_BASE)$(SEP)c_936.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_936.o: $(UNICODE_BASE_)c_936.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_949.o: $(UNICODE_BASE)$(SEP)c_949.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_949.o: $(UNICODE_BASE_)c_949.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_950.o: $(UNICODE_BASE)$(SEP)c_950.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_950.o: $(UNICODE_BASE_)c_950.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1006.o: $(UNICODE_BASE)$(SEP)c_1006.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1006.o: $(UNICODE_BASE_)c_1006.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1026.o: $(UNICODE_BASE)$(SEP)c_1026.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1026.o: $(UNICODE_BASE_)c_1026.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1250.o: $(UNICODE_BASE)$(SEP)c_1250.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1250.o: $(UNICODE_BASE_)c_1250.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1251.o: $(UNICODE_BASE)$(SEP)c_1251.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1251.o: $(UNICODE_BASE_)c_1251.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1252.o: $(UNICODE_BASE)$(SEP)c_1252.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1252.o: $(UNICODE_BASE_)c_1252.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1253.o: $(UNICODE_BASE)$(SEP)c_1253.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1253.o: $(UNICODE_BASE_)c_1253.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1254.o: $(UNICODE_BASE)$(SEP)c_1254.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1254.o: $(UNICODE_BASE_)c_1254.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1255.o: $(UNICODE_BASE)$(SEP)c_1255.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1255.o: $(UNICODE_BASE_)c_1255.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1256.o: $(UNICODE_BASE)$(SEP)c_1256.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1256.o: $(UNICODE_BASE_)c_1256.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1257.o: $(UNICODE_BASE)$(SEP)c_1257.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1257.o: $(UNICODE_BASE_)c_1257.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_1258.o: $(UNICODE_BASE)$(SEP)c_1258.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_1258.o: $(UNICODE_BASE_)c_1258.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_10000.o: $(UNICODE_BASE)$(SEP)c_10000.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_10000.o: $(UNICODE_BASE_)c_10000.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_10006.o: $(UNICODE_BASE)$(SEP)c_10006.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_10006.o: $(UNICODE_BASE_)c_10006.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_10007.o: $(UNICODE_BASE)$(SEP)c_10007.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_10007.o: $(UNICODE_BASE_)c_10007.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_10029.o: $(UNICODE_BASE)$(SEP)c_10029.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_10029.o: $(UNICODE_BASE_)c_10029.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_10079.o: $(UNICODE_BASE)$(SEP)c_10079.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_10079.o: $(UNICODE_BASE_)c_10079.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_10081.o: $(UNICODE_BASE)$(SEP)c_10081.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_10081.o: $(UNICODE_BASE_)c_10081.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_20866.o: $(UNICODE_BASE)$(SEP)c_20866.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_20866.o: $(UNICODE_BASE_)c_20866.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_20932.o: $(UNICODE_BASE)$(SEP)c_20932.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_20932.o: $(UNICODE_BASE_)c_20932.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_21866.o: $(UNICODE_BASE)$(SEP)c_21866.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_21866.o: $(UNICODE_BASE_)c_21866.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28591.o: $(UNICODE_BASE)$(SEP)c_28591.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28591.o: $(UNICODE_BASE_)c_28591.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28592.o: $(UNICODE_BASE)$(SEP)c_28592.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28592.o: $(UNICODE_BASE_)c_28592.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28593.o: $(UNICODE_BASE)$(SEP)c_28593.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28593.o: $(UNICODE_BASE_)c_28593.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28594.o: $(UNICODE_BASE)$(SEP)c_28594.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28594.o: $(UNICODE_BASE_)c_28594.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28595.o: $(UNICODE_BASE)$(SEP)c_28595.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28595.o: $(UNICODE_BASE_)c_28595.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28596.o: $(UNICODE_BASE)$(SEP)c_28596.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28596.o: $(UNICODE_BASE_)c_28596.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28597.o: $(UNICODE_BASE)$(SEP)c_28597.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28597.o: $(UNICODE_BASE_)c_28597.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28598.o: $(UNICODE_BASE)$(SEP)c_28598.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28598.o: $(UNICODE_BASE_)c_28598.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28599.o: $(UNICODE_BASE)$(SEP)c_28599.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28599.o: $(UNICODE_BASE_)c_28599.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28600.o: $(UNICODE_BASE)$(SEP)c_28600.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28600.o: $(UNICODE_BASE_)c_28600.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28603.o: $(UNICODE_BASE)$(SEP)c_28603.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28603.o: $(UNICODE_BASE_)c_28603.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28604.o: $(UNICODE_BASE)$(SEP)c_28604.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28604.o: $(UNICODE_BASE_)c_28604.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28605.o: $(UNICODE_BASE)$(SEP)c_28605.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28605.o: $(UNICODE_BASE_)c_28605.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
-$(UNICODE_BASE_DIR)$(SEP)c_28606.o: $(UNICODE_BASE)$(SEP)c_28606.c $(UNICODE_BASE_DIR_EXISTS)
+$(UNICODE_INT_)c_28606.o: $(UNICODE_BASE_)c_28606.c $(UNICODE_INT)
        $(ECHO_CC)
        ${host_gcc} $(UNICODE_HOST_CFLAGS) -c $< -o $@
 
index fabbb88..0bb0dfe 100644 (file)
@@ -1,17 +1,24 @@
 WINEBUILD_BASE = $(TOOLS_BASE)$(SEP)winebuild\r
+WINEBUILD_BASE_ = $(WINEBUILD_BASE)$(SEP)\r
+WINEBUILD_INT = $(INTERMEDIATE_)$(WINEBUILD_BASE)\r
+WINEBUILD_INT_ = $(WINEBUILD_INT)$(SEP)\r
+WINEBUILD_OUT = $(OUTPUT_)$(WINEBUILD_BASE)\r
+WINEBUILD_OUT_ = $(WINEBUILD_OUT)$(SEP)\r
 \r
-WINEBUILD_BASE_DIR = $(INTERMEDIATE)$(WINEBUILD_BASE)\r
-WINEBUILD_BASE_DIR_EXISTS = $(WINEBUILD_BASE_DIR)$(SEP)$(EXISTS)\r
+$(WINEBUILD_INT): $(TOOLS_INT)\r
+       $(ECHO_MKDIR)\r
+       ${mkdir} $@\r
 \r
-$(WINEBUILD_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)\r
+ifneq ($(INTERMEDIATE),$(OUTPUT))\r
+$(WINEBUILD_OUT): $(TOOLS_OUT)\r
        $(ECHO_MKDIR)\r
-       ${mkdir} $(WINEBUILD_BASE_DIR)\r
-       @echo . > $@\r
+       @{mkdir} $@\r
+endif\r
 \r
 WINEBUILD_TARGET = \\r
-       $(WINEBUILD_BASE_DIR)$(SEP)winebuild$(EXEPOSTFIX)\r
+       $(EXEPREFIX)$(WINEBUILD_OUT_)winebuild$(EXEPOSTFIX)\r
 \r
-WINEBUILD_SOURCES = $(addprefix $(WINEBUILD_BASE)$(SEP), \\r
+WINEBUILD_SOURCES = $(addprefix $(WINEBUILD_BASE_), \\r
        import.c \\r
        main.c \\r
        parser.c \\r
@@ -32,39 +39,39 @@ WINEBUILD_HOST_LFLAGS = -g
 .PHONY: winebuild\r
 winebuild: $(WINEBUILD_TARGET)\r
 \r
-$(WINEBUILD_TARGET): $(WINEBUILD_OBJECTS)\r
+$(WINEBUILD_TARGET): $(WINEBUILD_OBJECTS) $(WINEBUILD_OUT)\r
        $(ECHO_LD)\r
        ${host_gcc} $(WINEBUILD_OBJECTS) $(WINEBUILD_HOST_LFLAGS) -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)import.o: $(WINEBUILD_BASE)$(SEP)import.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)import.o: $(WINEBUILD_BASE_)import.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)main.o: $(WINEBUILD_BASE)$(SEP)main.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)main.o: $(WINEBUILD_BASE_)main.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)parser.o: $(WINEBUILD_BASE)$(SEP)parser.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)parser.o: $(WINEBUILD_BASE_)parser.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)res16.o: $(WINEBUILD_BASE)$(SEP)res16.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)res16.o: $(WINEBUILD_BASE_)res16.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)res32.o: $(WINEBUILD_BASE)$(SEP)res32.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)res32.o: $(WINEBUILD_BASE_)res32.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)spec32.o: $(WINEBUILD_BASE)$(SEP)spec32.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)spec32.o: $(WINEBUILD_BASE_)spec32.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)utils.o: $(WINEBUILD_BASE)$(SEP)utils.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)utils.o: $(WINEBUILD_BASE_)utils.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
-$(WINEBUILD_BASE_DIR)$(SEP)mkstemps.o: $(WINEBUILD_BASE)$(SEP)mkstemps.c $(WINEBUILD_BASE_DIR_EXISTS)\r
+$(WINEBUILD_INT_)mkstemps.o: $(WINEBUILD_BASE_)mkstemps.c $(WINEBUILD_INT)\r
        $(ECHO_CC)\r
        ${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@\r
 \r
index fd8f05e..d773f2f 100644 (file)
@@ -1,17 +1,24 @@
-WMC_BASE = $(TOOLS_BASE)$(SEP)wmc
-
-WMC_BASE_DIR = $(INTERMEDIATE)$(WMC_BASE)
-WMC_BASE_DIR_EXISTS = $(WMC_BASE_DIR)$(SEP)$(EXISTS)
+WMC_BASE = $(TOOLS_BASE_)wmc
+WMC_BASE_ = $(WMC_BASE)$(SEP)
+WMC_INT = $(INTERMEDIATE_)$(WMC_BASE)
+WMC_INT_ = $(WMC_INT)$(SEP)
+WMC_OUT = $(OUTPUT_)$(WMC_BASE)
+WMC_OUT_ = $(WMC_OUT)$(SEP)
+
+$(WMC_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(WMC_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(WMC_OUT): $(TOOLS_OUT)
        $(ECHO_MKDIR)
-       ${mkdir} $(WMC_BASE_DIR)
-       @echo . >$@
+       ${mkdir} $@
+endif
 
 WMC_TARGET = \
-       $(INTERMEDIATE)$(WMC_BASE)$(SEP)wmc$(EXEPOSTFIX)
+       $(EXEPREFIX)$(WMC_OUT_)wmc$(EXEPOSTFIX)
 
-WMC_SOURCES = $(addprefix $(WMC_BASE)$(SEP), \
+WMC_SOURCES = $(addprefix $(WMC_BASE_), \
        getopt.c \
        lang.c \
        mcl.c \
@@ -23,7 +30,7 @@ WMC_SOURCES = $(addprefix $(WMC_BASE)$(SEP), \
        )
 
 WMC_OBJECTS = \
-  $(addprefix $(INTERMEDIATE), $(WMC_SOURCES:.c=.o))
+  $(addprefix $(INTERMEDIATE_), $(WMC_SOURCES:.c=.o))
 
 WMC_HOST_CXXFLAGS = -I$(WMC_BASE) -g -Werror -Wall
 
@@ -32,39 +39,39 @@ WMC_HOST_LFLAGS = -g
 .PHONY: wmc
 wmc: $(WMC_TARGET)
 
-$(WMC_TARGET): $(WMC_OBJECTS)
+$(WMC_TARGET): $(WMC_OBJECTS) $(WMC_OUT)
        $(ECHO_LD)
        ${host_gcc} $(WMC_OBJECTS) $(WMC_HOST_LFLAGS) -o $@
 
-$(WMC_BASE_DIR)$(SEP)getopt.o: $(WMC_BASE)$(SEP)getopt.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)getopt.o: $(WMC_BASE_)getopt.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
-$(WMC_BASE_DIR)$(SEP)lang.o: $(WMC_BASE)$(SEP)lang.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)lang.o: $(WMC_BASE_)lang.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
-$(WMC_BASE_DIR)$(SEP)mcl.o: $(WMC_BASE)$(SEP)mcl.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)mcl.o: $(WMC_BASE_)mcl.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
-$(WMC_BASE_DIR)$(SEP)utils.o: $(WMC_BASE)$(SEP)utils.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)utils.o: $(WMC_BASE_)utils.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
-$(WMC_BASE_DIR)$(SEP)wmc.o: $(WMC_BASE)$(SEP)wmc.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)wmc.o: $(WMC_BASE_)wmc.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
-$(WMC_BASE_DIR)$(SEP)write.o: $(WMC_BASE)$(SEP)write.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)write.o: $(WMC_BASE_)write.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
-$(WMC_BASE_DIR)$(SEP)y_tab.o: $(WMC_BASE)$(SEP)y_tab.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)y_tab.o: $(WMC_BASE_)y_tab.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
-$(WMC_BASE_DIR)$(SEP)misc.o: $(WMC_BASE)$(SEP)misc.c $(WMC_BASE_DIR_EXISTS)
+$(WMC_INT_)misc.o: $(WMC_BASE_)misc.c $(WMC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WMC_HOST_CXXFLAGS) -c $< -o $@
 
index 59deb77..77c32dd 100644 (file)
@@ -1,47 +1,55 @@
-WPP_BASE = $(TOOLS_BASE)$(SEP)wpp
-
-WPP_BASE_DIR = $(INTERMEDIATE)$(WPP_BASE)
-WPP_BASE_DIR_EXISTS = $(WPP_BASE_DIR)$(SEP)$(EXISTS)
+WPP_BASE = $(TOOLS_BASE_)wpp
+WPP_BASE_ = $(WPP_BASE)$(SEP)
+WPP_INT = $(INTERMEDIATE_)$(WPP_BASE)
+WPP_INT_ = $(WPP_INT)$(SEP)
+WPP_OUT = $(OUTPUT_)$(WPP_BASE)
+WPP_OUT_ = $(WPP_OUT)$(SEP)
+
+$(WPP_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(WPP_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(WPP_OUT): $(TOOLS_OUT)
        $(ECHO_MKDIR)
-       ${mkdir} $(WPP_BASE_DIR)
-       @echo . > $@
+       ${mkdir} $@
+endif
 
 WPP_TARGET = \
-       $(WPP_BASE_DIR)$(SEP)libwpp.a
+       $(WPP_OUT_)libwpp.a
 
-WPP_SOURCES = \
-       $(WPP_BASE)$(SEP)lex.yy.c \
-       $(WPP_BASE)$(SEP)preproc.c \
-       $(WPP_BASE)$(SEP)wpp.c \
-       $(WPP_BASE)$(SEP)wpp.tab.c
+WPP_SOURCES = $(addprefix $(WPP_BASE_), \
+       lex.yy.c \
+       preproc.c \
+       wpp.c \
+       wpp.tab.c \
+       )
 
 WPP_OBJECTS = \
-    $(addprefix $(INTERMEDIATE), $(WPP_SOURCES:.c=.o))
+    $(addprefix $(INTERMEDIATE_), $(WPP_SOURCES:.c=.o))
 
 WPP_HOST_CFLAGS = -D__USE_W32API -I$(WPP_BASE) -Iinclude -Iinclude/wine -g
 
 .PHONY: wpp
 wpp: $(WPP_TARGET)
 
-$(WPP_TARGET): $(WPP_OBJECTS)
+$(WPP_TARGET): $(WPP_OBJECTS) $(WPP_OUT)
        $(ECHO_AR)
        ${host_ar} -rc $(WPP_TARGET) $(WPP_OBJECTS)
 
-$(WPP_BASE_DIR)$(SEP)lex.yy.o: $(WPP_BASE)$(SEP)lex.yy.c $(WPP_BASE_DIR_EXISTS)
+$(WPP_INT_)lex.yy.o: $(WPP_BASE_)lex.yy.c $(WPP_INT)
        $(ECHO_CC)
        ${host_gcc} $(WPP_HOST_CFLAGS) -c $< -o $@
 
-$(WPP_BASE_DIR)$(SEP)preproc.o: $(WPP_BASE)$(SEP)preproc.c $(WPP_BASE_DIR_EXISTS)
+$(WPP_INT_)preproc.o: $(WPP_BASE_)preproc.c $(WPP_INT)
        $(ECHO_CC)
        ${host_gcc} $(WPP_HOST_CFLAGS) -c $< -o $@
 
-$(WPP_BASE_DIR)$(SEP)wpp.o: $(WPP_BASE)$(SEP)wpp.c $(WPP_BASE_DIR_EXISTS)
+$(WPP_INT_)wpp.o: $(WPP_BASE_)wpp.c $(WPP_INT)
        $(ECHO_CC)
        ${host_gcc} $(WPP_HOST_CFLAGS) -c $< -o $@
 
-$(WPP_BASE_DIR)$(SEP)wpp.tab.o: $(WPP_BASE)$(SEP)wpp.tab.c $(WPP_BASE_DIR_EXISTS)
+$(WPP_INT_)wpp.tab.o: $(WPP_BASE_)wpp.tab.c $(WPP_INT)
        $(ECHO_CC)
        ${host_gcc} $(WPP_HOST_CFLAGS) -c $< -o $@
 
index 45ce8fd..2a9b985 100644 (file)
@@ -1,27 +1,41 @@
-WRC_BASE = $(TOOLS_BASE)$(SEP)wrc
-
-WRC_BASE_DIR = $(INTERMEDIATE)$(WRC_BASE)
-WRC_BASE_DIR_EXISTS = $(WRC_BASE_DIR)$(SEP)$(EXISTS)
+WRC_BASE = $(TOOLS_BASE_)wrc
+WRC_BASE_ = $(WRC_BASE)$(SEP)
+WRC_INT = $(INTERMEDIATE_)$(WRC_BASE)
+WRC_INT_ = $(WRC_INT)$(SEP)
+WRC_OUT = $(OUTPUT_)$(WRC_BASE)
+WRC_OUT_ = $(WRC_OUT)$(SEP)
+
+$(WRC_INT): $(TOOLS_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(WRC_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(WRC_OUT): $(TOOLS_OUT)
        $(ECHO_MKDIR)
-       ${mkdir} $(WRC_BASE_DIR)
-       @echo . > $@
+       ${mkdir} $@
+endif
 
 WRC_PORT_BASE = $(WRC_BASE)$(SEP)port
+WRC_PORT_BASE_ = $(WRC_PORT_BASE)$(SEP)
+WRC_PORT_INT = $(INTERMEDIATE_)$(WRC_PORT_BASE)
+WRC_PORT_INT_ = $(WRC_PORT_INT)$(SEP)
+WRC_PORT_OUT = $(OUTPUT_)$(WRC_PORT_BASE)
+WRC_PORT_OUT_ = $(WRC_PORT_OUT)$(SEP)
 
-WRC_PORT_BASE_DIR = $(INTERMEDIATE)$(WRC_PORT_BASE)
-WRC_PORT_BASE_DIR_EXISTS = $(WRC_PORT_BASE_DIR)$(SEP)$(EXISTS)
+$(WRC_PORT_INT): $(WRC_INT)
+       $(ECHO_MKDIR)
+       ${mkdir} $@
 
-$(WRC_PORT_BASE_DIR_EXISTS): $(WRC_BASE_DIR_EXISTS)
+ifneq ($(INTERMEDIATE),$(OUTPUT))
+$(WRC_PORT_OUT): $(WRC_OUT)
        $(ECHO_MKDIR)
-       ${mkdir} $(WRC_PORT_BASE_DIR)
-       @echo . > $@
+       ${mkdir} $@
+endif
 
 WRC_TARGET = \
-       $(WRC_BASE_DIR)$(SEP)wrc$(EXEPOSTFIX)
+       $(EXEPREFIX)$(WRC_BASE_)wrc$(EXEPOSTFIX)
 
-WRC_SOURCES = $(addprefix $(WRC_BASE)$(SEP), \
+WRC_SOURCES = $(addprefix $(WRC_BASE_), \
        dumpres.c \
        genres.c \
        newstruc.c \
@@ -36,7 +50,7 @@ WRC_SOURCES = $(addprefix $(WRC_BASE)$(SEP), \
        )
 
 WRC_OBJECTS = \
-  $(addprefix $(INTERMEDIATE), $(WRC_SOURCES:.c=.o))
+  $(addprefix $(INTERMEDIATE_), $(WRC_SOURCES:.c=.o))
 
 WRC_HOST_CFLAGS = -I$(WRC_BASE) -g -Werror -Wall \
                   -D__USE_W32API -DWINE_UNICODE_API= \
@@ -46,54 +60,56 @@ WRC_HOST_CFLAGS = -I$(WRC_BASE) -g -Werror -Wall \
 
 WRC_HOST_LFLAGS = -g
 
+WRC_LIBS = $(UNICODE_TARGET) $(WPP_TARGET)
+
 .PHONY: wrc
 wrc: $(WRC_TARGET)
 
-$(WRC_TARGET): $(WRC_OBJECTS) $(UNICODE_TARGET) $(WPP_TARGET)
+$(WRC_TARGET): $(WRC_OBJECTS) $(WRC_LIBS) $(WRC_OUT)
        $(ECHO_LD)
-       ${host_gcc} $(WRC_OBJECTS) $(UNICODE_TARGET) $(WPP_TARGET) $(WRC_HOST_LFLAGS) -o $@
+       ${host_gcc} $(WRC_OBJECTS) $(WRC_LIBS) $(WRC_HOST_LFLAGS) -o $@
 
-$(WRC_BASE_DIR)$(SEP)dumpres.o: $(WRC_BASE)$(SEP)dumpres.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)dumpres.o: $(WRC_BASE_)dumpres.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)genres.o: $(WRC_BASE)$(SEP)genres.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)genres.o: $(WRC_BASE_)genres.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)newstruc.o: $(WRC_BASE)$(SEP)newstruc.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)newstruc.o: $(WRC_BASE_)newstruc.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)readres.o: $(WRC_BASE)$(SEP)readres.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)readres.o: $(WRC_BASE_)readres.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)translation.o: $(WRC_BASE)$(SEP)translation.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)translation.o: $(WRC_BASE_)translation.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)utils.o: $(WRC_BASE)$(SEP)utils.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)utils.o: $(WRC_BASE_)utils.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)wrc.o: $(WRC_BASE)$(SEP)wrc.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)wrc.o: $(WRC_BASE_)wrc.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)writeres.o: $(WRC_BASE)$(SEP)writeres.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)writeres.o: $(WRC_BASE_)writeres.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)y.tab.o: $(WRC_BASE)$(SEP)y.tab.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)y.tab.o: $(WRC_BASE_)y.tab.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_BASE_DIR)$(SEP)lex.yy.o: $(WRC_BASE)$(SEP)lex.yy.c $(WRC_BASE_DIR_EXISTS)
+$(WRC_INT_)lex.yy.o: $(WRC_BASE_)lex.yy.c $(WRC_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@
 
-$(WRC_PORT_BASE_DIR)$(SEP)mkstemps.o: $(WRC_PORT_BASE)$(SEP)mkstemps.c $(WRC_PORT_BASE_DIR_EXISTS)
+$(WRC_PORT_INT_)mkstemps.o: $(WRC_PORT_BASE_)mkstemps.c $(WRC_PORT_INT)
        $(ECHO_CC)
        ${host_gcc} $(WRC_HOST_CFLAGS) -c $< -o $@