Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-30 21:51:47 +00:00
Code Issues Projects Releases Packages Wiki Activity

eliminate rmkdir and generate directory dependencies the right way.

Browse source 
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
This commit is contained in:
Royce Mitchell III 2005-03-22 07:25:53 +00:00
parent 297bfe4644
commit 8102c0deae
20 changed files with 1665 additions and 1477 deletions
Download patch file Download diff file Expand all files Collapse all files

31
reactos/Makefile
View 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

46
reactos/lib/zlib/zlib.mak
View file

@ -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_OUT)$(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_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)

37
reactos/tools/bin2res/bin2res.mak
View file

@ -1,35 +1,44 @@
BIN2RES_BASE = $(TOOLS_BASE)$(SEP)bin2res
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_BASE_DIR = $(INTERMEDIATE)$(BIN2RES_BASE)
BIN2RES_BASE_DIR_EXISTS = $(BIN2RES_BASE_DIR)$(SEP)$(EXISTS)
$(BIN2RES_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $@
$(BIN2RES_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
${mkdir} $(BIN2RES_BASE_DIR)
@echo . >$(BIN2RES_BASE_DIR_EXISTS)
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 $@

48
reactos/tools/buildno/buildno.mak
View file

@ -1,46 +1,54 @@
BUILDNO_BASE = $(TOOLS_BASE)$(SEP)buildno
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_BASE_DIR = $(INTERMEDIATE)$(BUILDNO_BASE)
BUILDNO_BASE_DIR_EXISTS = $(BUILDNO_BASE_DIR)$(SEP)$(EXISTS)
$(BUILDNO_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(BUILDNO_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(BUILDNO_BASE_DIR)
@echo. > $@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(BUILDNO_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
${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 $@

51
reactos/tools/cabman/cabman.mak
View file

@ -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 $@

38
reactos/tools/cdmake/cdmake.mak
View file

@ -1,22 +1,30 @@
CDMAKE_BASE = $(TOOLS_BASE)$(SEP)cdmake
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_BASE_DIR = $(INTERMEDIATE)$(CDMAKE_BASE)
CDMAKE_BASE_DIR_EXISTS = $(CDMAKE_BASE_DIR)$(SEP)$(EXISTS)
$(CDMAKE_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(CDMAKE_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(CDMAKE_BASE_DIR)
@echo . >$@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(CDMAKE_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
${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 $@

36
reactos/tools/nci/nci.mak
View 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

191
reactos/tools/rbuild/backend/mingw/mingw.cpp
View file

@ -3,12 +3,75 @@
#include "mingw.h"
#include <assert.h>
#include "modulehandler.h"
using std::string;
using std::vector;
using std::set;
using std::map;
typedef set<string> set_string;
typedef map<string,Directory*> directory_map;
class Directory
{
public:
string name;
directory_map subdirs;
Directory ( const string& name );
void Add ( const char* subdir );
void CreateRule ( FILE* f, const string& parent );
};
Directory::Directory ( const string& name_ )
: name(name_)
{
}
void Directory::Add ( const char* subdir )
{
const char* p = strpbrk ( subdir, "/\\" );
if ( !p )
p = subdir + strlen(subdir);
string s ( subdir, p-subdir );
if ( subdirs.find(s) == subdirs.end() )
subdirs[s] = new Directory(s);
if ( *p && *++p )
subdirs[s]->Add ( p );
}
void
Directory::CreateRule ( FILE* f, const string& parent )
{
string path;
if ( parent.size() )
{
fprintf ( f,
"%s%c%s: %s\n",
parent.c_str (),
CSEP,
name.c_str (),
parent.c_str () );
fprintf ( f,
"\t$(ECHO_MKDIR)\n" );
fprintf ( f,
"\t${mkdir} $@\n" );
path = parent + SSEP + name;
}
else
path = name;
for ( directory_map::iterator i = subdirs.begin();
i != subdirs.end();
++i )
{
i->second->CreateRule ( f, path );
}
}
static class MingwFactory : public Backend::Factory
{
@ -22,33 +85,82 @@ public:
MingwBackend::MingwBackend ( Project& project )
: Backend ( project )
: Backend ( project ),
int_directories ( new Directory("$(INTERMEDIATE)") ),
out_directories ( new Directory("$(OUTPUT)") )
{
}
void
MingwBackend::CreateDirectoryTargetIfNotYetCreated ( const string& directory )
MingwBackend::~MingwBackend()
{
directories.insert ( directory );
delete int_directories;
delete out_directories;
}
string
MingwBackend::AddDirectoryTarget ( const string& directory, bool out )
{
const char* dir_name = "$(INTERMEDIATE)";
Directory* dir = int_directories;
if ( out )
{
dir_name = "$(OUTPUT)";
dir = out_directories;
}
dir->Add ( directory.c_str() );
return dir_name;
}
void
MingwBackend::Process ()
{
size_t i;
DetectPCHSupport();
CreateMakefile ();
GenerateHeader ();
GenerateGlobalVariables ();
GenerateAllTarget ();
GenerateInitTarget ();
GenerateXmlBuildFilesMacro();
for ( size_t i = 0; i < ProjectNode.modules.size (); i++ )
vector<MingwModuleHandler*> v;
for ( i = 0; i < ProjectNode.modules.size (); i++ )
{
Module& module = *ProjectNode.modules[i];
ProcessModule ( module );
MingwModuleHandler* h = MingwModuleHandler::InstanciateHandler (
module,
this );
if ( module.host == HostDefault )
{
module.host = h->DefaultHost();
assert ( module.host != HostDefault );
}
v.push_back ( h );
}
size_t iend = v.size ();
for ( i = 0; i < iend; i++ )
v[i]->GenerateTargetMacro();
fprintf ( fMakefile, "\n" );
GenerateAllTarget ( v );
GenerateInitTarget ();
for ( i = 0; i < iend; i++ )
v[i]->GenerateOtherMacros();
for ( i = 0; i < iend; i++ )
{
MingwModuleHandler& h = *v[i];
h.GeneratePreconditionDependencies ();
h.Process ();
h.GenerateInvocations ();
h.GenerateCleanTarget ();
delete v[i];
}
GenerateDirectoryTargets ();
CheckAutomaticDependencies ();
CloseMakefile ();
@ -60,6 +172,7 @@ MingwBackend::CreateMakefile ()
fMakefile = fopen ( ProjectNode.makefile.c_str (), "w" );
if ( !fMakefile )
throw AccessDeniedException ( ProjectNode.makefile );
MingwModuleHandler::SetBackend ( this );
MingwModuleHandler::SetMakefile ( fMakefile );
MingwModuleHandler::SetUsePch ( use_pch );
}
@ -129,7 +242,7 @@ MingwBackend::GenerateGlobalCFlagsAndProperties (
if ( data.includes.size() || data.defines.size() )
{
GenerateProjectCFlagsMacro ( assignmentOperation,
data );
data );
}
for ( i = 0; i < data.ifs.size(); i++ )
@ -171,15 +284,6 @@ MingwBackend::GenerateProjectLFLAGS () const
void
MingwBackend::GenerateGlobalVariables () const
{
#define TOOL_PREFIX "$(Q)$(INTERMEDIATE)tools" SSEP
fprintf ( fMakefile, "winebuild = " TOOL_PREFIX "winebuild" SSEP "winebuild" EXEPOSTFIX "\n" );
fprintf ( fMakefile, "bin2res = " TOOL_PREFIX "bin2res" SSEP "bin2res" EXEPOSTFIX "\n" );
fprintf ( fMakefile, "cabman = " TOOL_PREFIX "cabman" SSEP "cabman" EXEPOSTFIX "\n" );
fprintf ( fMakefile, "cdmake = " TOOL_PREFIX "cdmake" SSEP "cdmake" EXEPOSTFIX "\n" );
fprintf ( fMakefile, "regtests = " TOOL_PREFIX "regtests" EXEPOSTFIX "\n" );
fprintf ( fMakefile, "rsym = " TOOL_PREFIX "rsym" EXEPOSTFIX "\n" );
fprintf ( fMakefile, "wrc = " TOOL_PREFIX "wrc" SSEP "wrc" EXEPOSTFIX "\n" );
fprintf ( fMakefile, "\n" );
GenerateGlobalCFlagsAndProperties (
"=",
ProjectNode.non_if_data );
@ -202,20 +306,21 @@ MingwBackend::IncludeInAllTarget ( const Module& module ) const
}
void
MingwBackend::GenerateAllTarget () const
MingwBackend::GenerateAllTarget ( const vector<MingwModuleHandler*>& handlers ) const
{
fprintf ( fMakefile, "all:" );
int wrap_count = 0;
for ( size_t i = 0; i < ProjectNode.modules.size (); i++ )
size_t iend = handlers.size ();
for ( size_t i = 0; i < iend; i++ )
{
Module& module = *ProjectNode.modules[i];
const Module& module = handlers[i]->module;
if ( IncludeInAllTarget ( module ) )
{
if ( wrap_count++ == 5 )
fprintf ( fMakefile, " \\\n\t\t" ), wrap_count = 0;
fprintf ( fMakefile,
" %s",
FixupTargetFilename ( module.GetPath () ).c_str () );
GetTargetMacro(module).c_str () );
}
}
fprintf ( fMakefile, "\n\t\n\n" );
@ -244,8 +349,7 @@ MingwBackend::GenerateInitTarget () const
fprintf ( fMakefile,
"INIT = %s\n",
GetBuildToolDependencies ().c_str () );
fprintf ( fMakefile,
"\n" );
fprintf ( fMakefile, "\n" );
}
void
@ -272,8 +376,7 @@ MingwBackend::GenerateXmlBuildFilesMacro() const
xmlbuildFilenames.c_str ());
if ( i == ProjectNode.xmlbuildfiles.size () - 1 )
{
fprintf ( fMakefile,
"\n" );
fprintf ( fMakefile, "\n" );
}
else
{
@ -285,8 +388,7 @@ MingwBackend::GenerateXmlBuildFilesMacro() const
}
numberOfExistingFiles++;
}
fprintf ( fMakefile,
"\n" );
fprintf ( fMakefile, "\n" );
}
void
@ -297,27 +399,10 @@ MingwBackend::CheckAutomaticDependencies ()
automaticDependency.CheckAutomaticDependencies ();
}
void
MingwBackend::ProcessModule ( Module& module )
{
MingwModuleHandler* h = MingwModuleHandler::InstanciateHandler (
module.node.location,
module.type,
this );
MingwModuleHandler::string_list clean_files;
if ( module.host == HostDefault )
{
module.host = h->DefaultHost();
assert ( module.host != HostDefault );
}
h->Process ( module, clean_files );
h->GenerateCleanTarget ( module, clean_files );
}
bool
MingwBackend::IncludeDirectoryTarget ( const string& directory ) const
{
if ( directory == "$(INTERMEDIATE)tools")
if ( directory == "$(INTERMEDIATE)" SSEP "tools")
return false;
else
return true;
@ -326,7 +411,15 @@ MingwBackend::IncludeDirectoryTarget ( const string& directory ) const
void
MingwBackend::GenerateDirectoryTargets ()
{
if ( directories.size () == 0 )
// TODO FIXME - write new directory creation
for ( int i = 0; i < 2; i++ )
{
Directory& d = *(!i ? int_directories : out_directories);
if ( i ) fprintf ( fMakefile, "ifneq ($(INTERMEDIATE),$(OUTPUT))\n" );
d.CreateRule ( fMakefile, "" );
if ( i ) fprintf ( fMakefile, "endif\n" );
}
/*if ( directories.size () == 0 )
return;
set_string::iterator i;
@ -345,13 +438,13 @@ MingwBackend::GenerateDirectoryTargets ()
}
}
directories.clear ();
directories.clear ();*/
}
string
FixupTargetFilename ( const string& targetFilename )
{
return string("$(INTERMEDIATE)") + NormalizeFilename ( targetFilename );
return NormalizeFilename ( targetFilename );
}
void

13
reactos/tools/rbuild/backend/mingw/mingw.h
View file

@ -2,17 +2,18 @@
#define MINGW_H
#include "../backend.h"
#include "modulehandler.h"
class Directory;
class MingwModuleHandler;
class MingwBackend : public Backend
{
public:
MingwBackend ( Project& project );
virtual ~MingwBackend () { };
virtual ~MingwBackend ();
virtual void Process ();
void CreateDirectoryTargetIfNotYetCreated ( const std::string& directory );
std::string AddDirectoryTarget ( const std::string& directory, bool out );
private:
void ProcessModule ( Module& module );
void CreateMakefile ();
void CloseMakefile () const;
void GenerateHeader () const;
@ -24,16 +25,16 @@ private:
void GenerateDirectoryTargets ();
void GenerateGlobalVariables () const;
bool IncludeInAllTarget ( const Module& module ) const;
void GenerateAllTarget () const;
void GenerateAllTarget ( const std::vector<MingwModuleHandler*>& handlers ) const;
std::string GetBuildToolDependencies () const;
void GenerateInitTarget () const;
void GenerateXmlBuildFilesMacro() const;
void CheckAutomaticDependencies ();
bool IncludeDirectoryTarget ( const std::string& directory ) const;
void DetectPCHSupport();
std::set<std::string> directories;
FILE* fMakefile;
bool use_pch;
Directory *int_directories, *out_directories;
};
std::string FixupTargetFilename ( const std::string& targetFilename );

1595
reactos/tools/rbuild/backend/mingw/modulehandler.cpp
View file

File diff suppressed because it is too large Load diff

298
reactos/tools/rbuild/backend/mingw/modulehandler.h
View file

@ -5,10 +5,9 @@
#include "mingw.h"
class MingwBackend;
extern std::string
ReplaceExtension ( const std::string& filename,
const std::string& newExtension );
GetTargetMacro ( const Module&, bool with_dollar = true );
extern std::string
PrefixFilename (
@ -18,332 +17,309 @@ PrefixFilename (
class MingwModuleHandler
{
public:
typedef std::vector<std::string> string_list;
MingwModuleHandler ( ModuleType moduletype,
MingwBackend* backend_ );
MingwModuleHandler ( const Module& module_ );
virtual ~MingwModuleHandler();
static void SetBackend ( MingwBackend* backend_ );
static void SetMakefile ( FILE* f );
static MingwModuleHandler* InstanciateHandler ( const std::string& location,
ModuleType moduletype_,
MingwBackend* backend_ );
static void SetUsePch ( bool use_pch );
static MingwModuleHandler* LookupHandler ( const std::string& location,
ModuleType moduletype_ );
static std::string PassThruCacheDirectory (
const std::string &f, bool out );
static std::string GetTargetFilename (
const Module& module,
string_list* pclean_files );
static std::string
GetImportLibraryFilename (
const Module& module,
string_list* pclean_files );
void GenerateTargetMacro();
void GenerateOtherMacros();
static MingwModuleHandler* InstanciateHandler ( const Module& module_,
MingwBackend* backend_ );
virtual HostType DefaultHost() = 0;
virtual void Process ( const Module& module, string_list& clean_files ) = 0;
void GenerateCleanTarget ( const Module& module,
const string_list& clean_files ) const;
void GeneratePreconditionDependencies ();
virtual void Process () = 0;
virtual std::string TypeSpecificCFlags() { return ""; }
virtual std::string TypeSpecificNasmFlags() { return ""; }
void GenerateInvocations () const;
void GenerateCleanTarget () const;
protected:
const std::string &PassThruCacheDirectory ( const std::string &f );
const std::string GetDirectoryDependency ( const std::string& file );
std::string GetWorkingDirectory () const;
std::string GetBasename ( const std::string& filename ) const;
std::string GetActualSourceFilename ( const std::string& filename ) const;
std::string GetModuleArchiveFilename ( const Module& module ) const;
std::string GetModuleArchiveFilename () const;
bool IsGeneratedFile ( const File& file ) const;
std::string GetImportLibraryDependency ( const Module& importedModule );
std::string GetModuleDependencies ( const Module& module );
std::string GetAllDependencies ( const Module& module ) const;
std::string GetSourceFilenames ( const Module& module,
bool includeGeneratedFiles ) const;
std::string GetSourceFilenames ( const Module& module ) const;
std::string GetSourceFilenamesWithoutGeneratedFiles ( const Module& module ) const;
void GetModuleDependencies ( string_list& dependencies );
std::string GetAllDependencies () const;
void GetSourceFilenames ( string_list& list, bool includeGeneratedFiles = true ) const;
void GetSourceFilenamesWithoutGeneratedFiles ( string_list& list ) const;
std::string GetObjectFilename ( const std::string& sourceFilename,
string_list* pclean_files ) const;
std::string GetObjectFilenames ( const Module& module );
void GenerateInvocations ( const Module& module ) const;
std::string GetObjectFilenames ();
std::string GetPreconditionDependenciesName ( const Module& module ) const;
void GeneratePreconditionDependencies ( const Module& module );
std::string GetCFlagsMacro ( const Module& module ) const;
std::string GetObjectsMacro ( const Module& module ) const;
std::string GetLinkingDependenciesMacro ( const Module& module ) const;
std::string GetLibsMacro ( const Module& module ) const;
std::string GetLinkerMacro ( const Module& module ) const;
void GenerateLinkerCommand ( const Module& module,
const std::string& target,
const std::string& dependencies,
std::string GetPreconditionDependenciesName () const;
std::string GetCFlagsMacro () const;
static std::string GetObjectsMacro ( const Module& );
std::string GetLinkingDependenciesMacro () const;
std::string GetLibsMacro () const;
std::string GetLinkerMacro () const;
void GenerateLinkerCommand ( const std::string& dependencies,
const std::string& linker,
const std::string& linkerParameters,
const std::string& objectsMacro,
const std::string& libsMacro,
string_list& clean_files ) const;
void GenerateMacrosAndTargets ( const Module& module,
const std::string* clags,
const std::string* nasmflags,
string_list& clean_files );
void GenerateImportLibraryTargetIfNeeded ( const Module& module, string_list& clean_files );
std::string GetDefinitionDependencies ( const Module& module );
std::string GetLinkingDependencies ( const Module& module ) const;
bool IsCPlusPlusModule ( const Module& module );
static FILE* fMakefile;
const std::string& libsMacro );
void GeneratePhonyTarget() const;
void GenerateRules ();
void GenerateImportLibraryTargetIfNeeded ();
void GetDefinitionDependencies ( string_list& dependencies ) const;
std::string GetLinkingDependencies () const;
static MingwBackend* backend;
static FILE* fMakefile;
static bool use_pch;
private:
std::string ConcatenatePaths ( const std::string& path1,
const std::string& path2 ) const;
std::string GenerateGccDefineParametersFromVector ( const std::vector<Define*>& defines ) const;
std::string GenerateGccDefineParameters ( const Module& module ) const;
std::string GenerateGccDefineParameters () const;
std::string GenerateGccIncludeParametersFromVector ( const std::vector<Include*>& includes ) const;
std::string GenerateCompilerParametersFromVector ( const std::vector<CompilerFlag*>& compilerFlags ) const;
std::string GenerateLinkerParametersFromVector ( const std::vector<LinkerFlag*>& linkerFlags ) const;
std::string GenerateImportLibraryDependenciesFromVector ( const std::vector<Library*>& libraries );
std::string GenerateLinkerParameters ( const Module& module ) const;
std::string GenerateLinkerParameters () const;
void GenerateMacro ( const char* assignmentOperation,
const std::string& macro,
const IfableData& data,
const std::vector<CompilerFlag*>* compilerFlags );
void GenerateMacros (
const Module& module,
const char* op,
void GenerateMacros ( const char* op,
const IfableData& data,
const std::vector<CompilerFlag*>* compilerFlags,
const std::vector<LinkerFlag*>* linkerFlags,
const std::string& cflags_macro,
const std::string& nasmflags_macro,
const std::string& windresflags_macro,
const std::string& linkerflags_macro,
const std::string& objs_macro,
const std::string& libs_macro,
const std::string& linkdeps_macro );
void GenerateMacros ( const Module& module,
const std::string& cflags_macro,
const std::string& nasmflags_macro,
const std::string& windresflags_macro,
const std::string& linkerflags_macro,
const std::string& objs_macro,
const std::string& libs_macro,
const std::string& linkDepsMacro );
std::string GenerateGccIncludeParameters ( const Module& module ) const;
std::string GenerateGccParameters ( const Module& module ) const;
std::string GenerateNasmParameters ( const Module& module ) const;
void GenerateGccCommand ( const Module& module,
const std::string& sourceFilename,
const std::vector<LinkerFlag*>* linkerFlags );
std::string GenerateGccIncludeParameters () const;
std::string GenerateGccParameters () const;
std::string GenerateNasmParameters () const;
void GenerateGccCommand ( const std::string& sourceFilename,
const std::string& cc,
const std::string& cflagsMacro );
void GenerateGccAssemblerCommand ( const Module& module,
const std::string& sourceFilename,
void GenerateGccAssemblerCommand ( const std::string& sourceFilename,
const std::string& cc,
const std::string& cflagsMacro );
void GenerateNasmCommand ( const Module& module,
const std::string& sourceFilename,
void GenerateNasmCommand ( const std::string& sourceFilename,
const std::string& nasmflagsMacro );
void GenerateWindresCommand ( const Module& module,
const std::string& sourceFilename,
void GenerateWindresCommand ( const std::string& sourceFilename,
const std::string& windresflagsMacro );
void GenerateWinebuildCommands ( const Module& module,
const std::string& sourceFilename,
string_list& clean_files ) const;
void GenerateCommands ( const Module& module,
const std::string& sourceFilename,
void GenerateWinebuildCommands ( const std::string& sourceFilename );
void GenerateCommands ( const std::string& sourceFilename,
const std::string& cc,
const std::string& cppc,
const std::string& cflagsMacro,
const std::string& nasmflagsMacro,
const std::string& windresflagsMacro,
string_list& clean_files );
void GenerateObjectFileTargets ( const Module& module,
const IfableData& data,
const std::string& windresflagsMacro );
void GenerateObjectFileTargets ( const IfableData& data,
const std::string& cc,
const std::string& cppc,
const std::string& cflagsMacro,
const std::string& nasmflagsMacro,
const std::string& windresflagsMacro,
string_list& clean_files );
void GenerateObjectFileTargets ( const Module& module,
const std::string& cc,
const std::string& windresflagsMacro );
void GenerateObjectFileTargets ( const std::string& cc,
const std::string& cppc,
const std::string& cflagsMacro,
const std::string& nasmflagsMacro,
const std::string& windresflagsMacro,
string_list& clean_files );
std::string GenerateArchiveTarget ( const Module& module,
const std::string& ar,
const std::string& windresflagsMacro );
std::string GenerateArchiveTarget ( const std::string& ar,
const std::string& objs_macro ) const;
std::string GetSpecObjectDependencies ( const std::string& filename ) const;
std::string GetDefaultDependencies ( const Module& module ) const;
std::string GetInvocationDependencies ( const Module& module );
MingwBackend* backend;
void GetSpecObjectDependencies ( string_list& dependencies,
const std::string& filename ) const;
void GetDefaultDependencies ( string_list& dependencies ) const;
void GetInvocationDependencies ( const Module& module, string_list& dependencies );
public:
const Module& module;
string_list clean_files;
std::string cflagsMacro, nasmflagsMacro, windresflagsMacro,
linkerflagsMacro, objectsMacro, libsMacro, linkDepsMacro;
};
class MingwBuildToolModuleHandler : public MingwModuleHandler
{
public:
MingwBuildToolModuleHandler ( MingwBackend* backend );
MingwBuildToolModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostTrue; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateBuildToolModuleTarget ( const Module& module, string_list& clean_files );
void GenerateBuildToolModuleTarget ();
};
class MingwKernelModuleHandler : public MingwModuleHandler
{
public:
MingwKernelModuleHandler ( MingwBackend* backend );
MingwKernelModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateKernelModuleTarget ( const Module& module, string_list& clean_files );
void GenerateKernelModuleTarget ();
};
class MingwStaticLibraryModuleHandler : public MingwModuleHandler
{
public:
MingwStaticLibraryModuleHandler ( MingwBackend* backend );
MingwStaticLibraryModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateStaticLibraryModuleTarget ( const Module& module, string_list& clean_files );
void GenerateStaticLibraryModuleTarget ();
};
class MingwObjectLibraryModuleHandler : public MingwModuleHandler
{
public:
MingwObjectLibraryModuleHandler ( MingwBackend* backend );
MingwObjectLibraryModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateObjectLibraryModuleTarget ( const Module& module, string_list& clean_files );
void GenerateObjectLibraryModuleTarget ();
};
class MingwKernelModeDLLModuleHandler : public MingwModuleHandler
{
public:
MingwKernelModeDLLModuleHandler ( MingwBackend* backend );
MingwKernelModeDLLModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateKernelModeDLLModuleTarget ( const Module& module, string_list& clean_files );
void GenerateKernelModeDLLModuleTarget ();
};
class MingwKernelModeDriverModuleHandler : public MingwModuleHandler
{
public:
MingwKernelModeDriverModuleHandler ( MingwBackend* backend );
MingwKernelModeDriverModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
std::string TypeSpecificCFlags() { return "-D__NTDRIVER__"; }
private:
void GenerateKernelModeDriverModuleTarget ( const Module& module, string_list& clean_files );
void GenerateKernelModeDriverModuleTarget ();
};
class MingwNativeDLLModuleHandler : public MingwModuleHandler
{
public:
MingwNativeDLLModuleHandler ( MingwBackend* backend );
MingwNativeDLLModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateNativeDLLModuleTarget ( const Module& module, string_list& clean_files );
void GenerateNativeDLLModuleTarget ();
};
class MingwNativeCUIModuleHandler : public MingwModuleHandler
{
public:
MingwNativeCUIModuleHandler ( MingwBackend* backend );
MingwNativeCUIModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
std::string TypeSpecificCFlags() { return "-D__NTAPP__"; }
private:
void GenerateNativeCUIModuleTarget ( const Module& module, string_list& clean_files );
void GenerateNativeCUIModuleTarget ();
};
class MingwWin32DLLModuleHandler : public MingwModuleHandler
{
public:
MingwWin32DLLModuleHandler ( MingwBackend* backend );
MingwWin32DLLModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateExtractWineDLLResourcesTarget ( const Module& module, string_list& clean_files );
void GenerateWin32DLLModuleTarget ( const Module& module, string_list& clean_files );
void GenerateExtractWineDLLResourcesTarget ();
void GenerateWin32DLLModuleTarget ();
};
class MingwWin32CUIModuleHandler : public MingwModuleHandler
{
public:
MingwWin32CUIModuleHandler ( MingwBackend* backend );
MingwWin32CUIModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateWin32CUIModuleTarget ( const Module& module, string_list& clean_files );
void GenerateWin32CUIModuleTarget ();
};
class MingwWin32GUIModuleHandler : public MingwModuleHandler
{
public:
MingwWin32GUIModuleHandler ( MingwBackend* backend );
MingwWin32GUIModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateWin32GUIModuleTarget ( const Module& module, string_list& clean_files );
void GenerateWin32GUIModuleTarget ();
};
class MingwBootLoaderModuleHandler : public MingwModuleHandler
{
public:
MingwBootLoaderModuleHandler ( MingwBackend* backend );
MingwBootLoaderModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateBootLoaderModuleTarget ( const Module& module, string_list& clean_files );
void GenerateBootLoaderModuleTarget ();
};
class MingwBootSectorModuleHandler : public MingwModuleHandler
{
public:
MingwBootSectorModuleHandler ( MingwBackend* backend );
MingwBootSectorModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
std::string TypeSpecificNasmFlags() { return "-f bin"; }
private:
void GenerateBootSectorModuleTarget ( const Module& module, string_list& clean_files );
void GenerateBootSectorModuleTarget ();
};
class MingwIsoModuleHandler : public MingwModuleHandler
{
public:
MingwIsoModuleHandler ( MingwBackend* backend );
MingwIsoModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateIsoModuleTarget ( const Module& module, string_list& clean_files );
std::string GetBootstrapCdDirectories ( const std::string& bootcdDirectory,
const Module& module );
std::string GetNonModuleCdDirectories ( const std::string& bootcdDirectory,
const Module& module );
std::string GetCdDirectories ( const std::string& bootcdDirectory,
const Module& module );
void GetBootstrapCdFiles ( std::vector<std::string>& out,
const Module& module ) const;
void GetNonModuleCdFiles ( std::vector<std::string>& out,
const Module& module ) const;
void GetCdFiles ( std::vector<std::string>& out,
const Module& module ) const;
void OutputBootstrapfileCopyCommands ( const std::string& bootcdDirectory,
const Module& module );
void OutputCdfileCopyCommands ( const std::string& bootcdDirectory,
const Module& module );
void GenerateIsoModuleTarget ();
std::string GetBootstrapCdDirectories ( const std::string& bootcdDirectory );
std::string GetNonModuleCdDirectories ( const std::string& bootcdDirectory );
std::string GetCdDirectories ( const std::string& bootcdDirectory );
void GetBootstrapCdFiles ( std::vector<std::string>& out ) const;
void GetNonModuleCdFiles ( std::vector<std::string>& out ) const;
void GetCdFiles ( std::vector<std::string>& out ) const;
void OutputBootstrapfileCopyCommands ( const std::string& bootcdDirectory );
void OutputCdfileCopyCommands ( const std::string& bootcdDirectory );
};
class MingwTestModuleHandler : public MingwModuleHandler
{
public:
MingwTestModuleHandler ( MingwBackend* backend );
MingwTestModuleHandler ( const Module& module );
virtual HostType DefaultHost() { return HostFalse; }
virtual void Process ( const Module& module, string_list& clean_files );
virtual void Process ();
private:
void GenerateTestModuleTarget ( const Module& module, string_list& clean_files );
void GenerateTestModuleTarget ();
};
#endif /* MINGW_MODULEHANDLER_H */

55
reactos/tools/rbuild/module.cpp
View file

@ -19,6 +19,24 @@ FixSeparator ( const string& s )
return s2;
}
string
ReplaceExtension (
const string& filename,
const string& newExtension )
{
size_t index = filename.find_last_of ( '/' );
if ( index == string::npos )
index = 0;
size_t index2 = filename.find_last_of ( '\\' );
if ( index2 != string::npos && index2 > index )
index = index2;
string tmp = filename.substr( index /*, filename.size() - index*/ );
size_t ext_index = tmp.find_last_of( '.' );
if ( ext_index != string::npos )
return filename.substr ( 0, index + ext_index ) + newExtension;
return filename + newExtension;
}
string
GetSubPath (
const string& location,
@ -542,11 +560,12 @@ Module::GetDependencyPath () const
{
if ( HasImportLibrary () )
{
return ssprintf ( "dk%cnkm%clib%clib%s.a",
return ReplaceExtension ( GetPath(), ".a" );
/*return ssprintf ( "dk%cnkm%clib%clib%s.a",
CSEP,
CSEP,
CSEP,
name.c_str () );
name.c_str () );*/
}
else
return GetPath();
@ -570,23 +589,19 @@ Module::GetPathWithPrefix ( const string& prefix ) const
return path + CSEP + prefix + GetTargetName ();
}
string
Module::GetTargets () const
void
Module::GetTargets ( string_list& targets ) const
{
if ( invocations.size () > 0 )
{
string targets ( "" );
for ( size_t i = 0; i < invocations.size (); i++ )
{
Invoke& invoke = *invocations[i];
if ( targets.length () > 0 )
targets += " ";
targets += invoke.GetTargets ();
invoke.GetTargets ( targets );
}
return targets;
}
else
return GetPath ();
targets.push_back ( GetPath () );
}
string
@ -751,23 +766,20 @@ Invoke::ProcessXMLSubElementOutput ( const XMLElement& e )
subs_invalid = true;
}
if ( subs_invalid && e.subElements.size() > 0 )
throw InvalidBuildFileException ( e.location,
"<%s> cannot have sub-elements",
e.name.c_str() );
throw InvalidBuildFileException (
e.location,
"<%s> cannot have sub-elements",
e.name.c_str() );
}
string
Invoke::GetTargets () const
void
Invoke::GetTargets ( string_list& targets ) const
{
string targets ( "" );
for ( size_t i = 0; i < output.size (); i++ )
{
InvokeFile& file = *output[i];
if ( targets.length () > 0 )
targets += " ";
targets += NormalizeFilename ( file.name );
targets.push_back ( NormalizeFilename ( file.name ) );
}
return targets;
}
string
@ -782,8 +794,7 @@ Invoke::GetParameters () const
InvokeFile& invokeFile = *output[i];
if ( invokeFile.switches.length () > 0 )
{
parameters += invokeFile.switches;
parameters += " ";
parameters += invokeFile.switches + " ";
}
parameters += invokeFile.name;
}

11
reactos/tools/rbuild/rbuild.h
View file

@ -22,6 +22,8 @@
#include "exception.h"
#include "XML.h"
typedef std::vector<std::string> string_list;
#ifdef WIN32
#define EXEPREFIX ""
#define EXEPOSTFIX ".exe"
@ -180,7 +182,7 @@ public:
std::string GetBasePath () const;
std::string GetPath () const;
std::string GetPathWithPrefix ( const std::string& prefix ) const;
std::string GetTargets () const;
void GetTargets ( string_list& ) const;
std::string GetInvocationTarget ( const int index ) const;
bool HasFileWithExtension ( const IfableData&, const std::string& extension ) const;
void InvokeModule () const;
@ -278,7 +280,7 @@ public:
const Module& _module );
void ProcessXML();
std::string GetTargets () const;
void GetTargets ( string_list& targets ) const;
std::string GetParameters () const;
private:
void ProcessXMLSubElement ( const XMLElement& e );
@ -562,6 +564,11 @@ public:
extern std::string
FixSeparator ( const std::string& s );
extern std::string
ReplaceExtension (
const std::string& filename,
const std::string& newExtension );
extern std::string
GetSubPath (
const std::string& location,

231
reactos/tools/rbuild/rbuild.mak
View file

@ -1,62 +1,125 @@
RBUILD_BASE = $(TOOLS_BASE)$(SEP)rbuild
RBUILD_BASE = $(TOOLS_BASE_)rbuild
RBUILD_BASE_ = $(RBUILD_BASE)$(SEP)
RBUILD_INT = $(INTERMEDIATE_)$(RBUILD_BASE)
RBUILD_INT_ = $(RBUILD_INT)$(SEP)
RBUILD_OUT = $(OUTPUT_)$(RBUILD_BASE)
RBUILD_OUT_ = $(RBUILD_OUT)$(SEP)
RBUILD_BASE_DIR = $(INTERMEDIATE)$(RBUILD_BASE)
RBUILD_BASE_DIR_EXISTS = $(RBUILD_BASE_DIR)$(SEP)$(EXISTS)
$(RBUILD_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(RBUILD_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(RBUILD_BASE_DIR)
@echo . >$@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(RBUILD_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
${mkdir} $@
endif
RBUILD_BACKEND_BASE = $(RBUILD_BASE_)backend
RBUILD_BACKEND_BASE_ = $(RBUILD_BACKEND_BASE)$(SEP)
RBUILD_BACKEND_INT = $(INTERMEDIATE_)$(RBUILD_BACKEND_BASE)
RBUILD_BACKEND_INT_ = $(RBUILD_BACKEND_INT)$(SEP)
RBUILD_BACKEND_OUT = $(OUTPUT)$(RBUILD_BACKEND_BASE)
RBUILD_BACKEND_OUT_ = $(RBUILD_BACKEND_OUT)$(SEP)
$(RBUILD_BACKEND_INT): $(RBUILD_INT)
$(ECHO_MKDIR)
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(RBUILD_BACKEND_OUT): $(RBUILD_OUT)
$(ECHO_MKDIR)
${mkdir} $@
endif
RBUILD_MINGW_BASE = $(RBUILD_BACKEND_BASE_)mingw
RBUILD_MINGW_BASE_ = $(RBUILD_MINGW_BASE)$(SEP)
RBUILD_MINGW_INT = $(INTERMEDIATE_)$(RBUILD_MINGW_BASE)
RBUILD_MINGW_INT_ = $(RBUILD_MINGW_INT)$(SEP)
RBUILD_MINGW_OUT = $(OUTPUT)$(RBUILD_MINGW_BASE)
RBUILD_MINGW_OUT_ = $(RBUILD_MINGW_OUT)$(SEP)
$(RBUILD_MINGW_INT): $(RBUILD_BACKEND_INT)
$(ECHO_MKDIR)
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(RBUILD_MINGW_OUT): $(RBUILD_BACKEND_OUT)
$(ECHO_MKDIR)
${mkdir} $@
endif
RBUILD_DEVCPP_BASE = $(RBUILD_BACKEND_BASE_)devcpp
RBUILD_DEVCPP_BASE_ = $(RBUILD_DEVCPP_BASE)$(SEP)
RBUILD_DEVCPP_INT = $(INTERMEDIATE_)$(RBUILD_DEVCPP_BASE)
RBUILD_DEVCPP_INT_ = $(RBUILD_DEVCPP_INT)$(SEP)
RBUILD_DEVCPP_OUT = $(OUTPUT)$(RBUILD_DEVCPP_BASE)
RBUILD_DEVCPP_OUT_ = $(RBUILD_DEVCPP_OUT)$(SEP)
$(RBUILD_DEVCPP_INT): $(RBUILD_BACKEND_INT)
$(ECHO_MKDIR)
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(RBUILD_DEVCPP_OUT): $(RBUILD_BACKEND_OUT)
$(ECHO_MKDIR)
${mkdir} $@
endif
RBUILD_TARGET = \
$(RBUILD_BASE_DIR)$(SEP)rbuild$(EXEPOSTFIX)
$(EXEPREFIX)$(RBUILD_OUT_)rbuild$(EXEPOSTFIX)
RBUILD_TEST_TARGET = \
$(RBUILD_BASE_DIR)$(SEP)rbuild_test$(EXEPOSTFIX)
$(EXEPREFIX)$(RBUILD_OUT_)rbuild_test$(EXEPOSTFIX)
RBUILD_BACKEND_MINGW_BASE_SOURCES = \
backend$(SEP)mingw$(SEP)mingw.cpp \
backend$(SEP)mingw$(SEP)modulehandler.cpp
RBUILD_BACKEND_MINGW_BASE_SOURCES = $(addprefix $(RBUILD_MINGW_BASE_), \
mingw.cpp \
modulehandler.cpp \
)
RBUILD_BACKEND_DEVCPP_BASE_SOURCES = \
backend$(SEP)devcpp$(SEP)devcpp.cpp
RBUILD_BACKEND_DEVCPP_BASE_SOURCES = $(addprefix $(RBUILD_DEVCPP_BASE_), \
devcpp.cpp \
)
RBUILD_BACKEND_BASE_SOURCES = \
RBUILD_BACKEND_SOURCES = \
$(RBUILD_BACKEND_MINGW_BASE_SOURCES) \
$(RBUILD_BACKEND_DEVCPP_BASE_SOURCES) \
backend$(SEP)backend.cpp
RBUILD_BASE_SOURCES = \
$(RBUILD_BACKEND_BASE_SOURCES) \
automaticdependency.cpp \
bootstrap.cpp \
cdfile.cpp \
compilerflag.cpp \
define.cpp \
exception.cpp \
include.cpp \
linkerflag.cpp \
module.cpp \
project.cpp \
ssprintf.cpp \
stubbedcomponent.cpp \
XML.cpp
$(RBUILD_BACKEND_BASE_)backend.cpp
RBUILD_COMMON_SOURCES = \
$(addprefix $(RBUILD_BASE)$(SEP), $(RBUILD_BASE_SOURCES)) \
$(RBUILD_BACKEND_SOURCES) \
$(addprefix $(RBUILD_BASE_), \
automaticdependency.cpp \
bootstrap.cpp \
cdfile.cpp \
compilerflag.cpp \
define.cpp \
exception.cpp \
include.cpp \
linkerflag.cpp \
module.cpp \
project.cpp \
ssprintf.cpp \
stubbedcomponent.cpp \
XML.cpp \
)
RBUILD_SPECIAL_SOURCES = \
$(RBUILD_BASE)$(SEP)rbuild.cpp
$(RBUILD_BASE_)rbuild.cpp
RBUILD_SOURCES = \
$(RBUILD_COMMON_SOURCES) \
$(RBUILD_SPECIAL_SOURCES)
RBUILD_COMMON_OBJECTS = \
$(addprefix $(ROS_INTERMEDIATE), $(RBUILD_COMMON_SOURCES:.cpp=.o))
$(addprefix $(INTERMEDIATE_), $(RBUILD_COMMON_SOURCES:.cpp=.o))
RBUILD_SPECIAL_OBJECTS = \
$(addprefix $(ROS_INTERMEDIATE), $(RBUILD_SPECIAL_SOURCES:.cpp=.o))
$(addprefix $(INTERMEDIATE_), $(RBUILD_SPECIAL_SOURCES:.cpp=.o))
RBUILD_OBJECTS = \
$(RBUILD_COMMON_OBJECTS) \
@ -76,15 +139,15 @@ RBUILD_TESTS = \
tests$(SEP)symboltest.cpp
RBUILD_TEST_SPECIAL_SOURCES = \
$(addprefix $(RBUILD_BASE)$(SEP), $(RBUILD_TESTS)) \
$(RBUILD_BASE)$(SEP)tests$(SEP)alltests.cpp
$(addprefix $(RBUILD_BASE_), $(RBUILD_TESTS)) \
$(RBUILD_BASE_)tests$(SEP)alltests.cpp
RBUILD_TEST_SOURCES = \
$(RBUILD_COMMON_SOURCES) \
$(RBUILD_TEST_SPECIAL_SOURCES)
RBUILD_TEST_SPECIAL_OBJECTS = \
$(addprefix $(ROS_INTERMEDIATE), $(RBUILD_TEST_SPECIAL_SOURCES:.cpp=.o))
$(addprefix $(INTERMEDIATE_), $(RBUILD_TEST_SPECIAL_SOURCES:.cpp=.o))
RBUILD_TEST_OBJECTS = \
$(RBUILD_COMMON_OBJECTS) \
@ -97,26 +160,98 @@ RBUILD_HOST_LFLAGS = -g
.PHONY: rbuild
rbuild: $(RBUILD_TARGET)
$(RBUILD_TARGET): $(RBUILD_OBJECTS) $(RBUILD_BASE_DIR_EXISTS)
$(RBUILD_TARGET): $(RBUILD_OBJECTS) $(RBUILD_OUT)
$(ECHO_LD)
${host_gpp} $(RBUILD_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $(RBUILD_TARGET)
${host_gpp} $(RBUILD_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $@
$(RBUILD_COMMON_OBJECTS): %.o: %.cpp
$(RBUILD_INT_)automaticdependency.o: $(RBUILD_BASE_)automaticdependency.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_SPECIAL_OBJECTS): %.o: %.cpp
$(RBUILD_INT_)bootstrap.o: $(RBUILD_BASE_)bootstrap.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_TEST_TARGET): $(RBUILD_TEST_OBJECTS) $(RBUILD_BASE_DIR_EXISTS)
$(ECHO_LD)
${host_gpp} $(RBUILD_TEST_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $(RBUILD_TEST_TARGET)
$(RBUILD_TEST_SPECIAL_OBJECTS): %.o: %.cpp
$(RBUILD_INT_)cdfile.o: $(RBUILD_BASE_)cdfile.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)compilerflag.o: $(RBUILD_BASE_)compilerflag.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)define.o: $(RBUILD_BASE_)define.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)exception.o: $(RBUILD_BASE_)exception.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)include.o: $(RBUILD_BASE_)include.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)linkerflag.o: $(RBUILD_BASE_)linkerflag.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)module.o: $(RBUILD_BASE_)module.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)project.o: $(RBUILD_BASE_)project.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)rbuild.o: $(RBUILD_BASE_)rbuild.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)ssprintf.o: $(RBUILD_BASE_)ssprintf.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)stubbedcomponent.o: $(RBUILD_BASE_)stubbedcomponent.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_INT_)XML.o: $(RBUILD_BASE_)XML.cpp $(RBUILD_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_BACKEND_INT_)backend.o: $(RBUILD_BACKEND_BASE_)backend.cpp $(RBUILD_BACKEND_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_MINGW_INT_)mingw.o: $(RBUILD_MINGW_BASE_)mingw.cpp $(RBUILD_MINGW_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_MINGW_INT_)modulehandler.o: $(RBUILD_MINGW_BASE_)modulehandler.cpp $(RBUILD_MINGW_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
$(RBUILD_DEVCPP_INT_)devcpp.o: $(RBUILD_DEVCPP_BASE_)devcpp.cpp $(RBUILD_DEVCPP_INT)
$(ECHO_CC)
${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
#$(RBUILD_COMMON_OBJECTS): %.o: %.cpp $(RBUILD_INT)
# $(ECHO_CC)
# ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
#$(RBUILD_SPECIAL_OBJECTS): %.o: %.cpp $(RBUILD_INT)
# $(ECHO_CC)
# ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
#$(RBUILD_TEST_TARGET): $(RBUILD_TEST_OBJECTS) $(RBUILD_OUT)
# $(ECHO_LD)
# ${host_gpp} $(RBUILD_TEST_OBJECTS) $(RBUILD_HOST_LFLAGS) -o $@
#$(RBUILD_TEST_SPECIAL_OBJECTS): %.o: %.cpp $(RBUILD_INT)
# $(ECHO_CC)
# ${host_gpp} $(RBUILD_HOST_CXXFLAGS) -c $< -o $@
.PHONY: rbuild_test

75
reactos/tools/tools.mak
View 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_ = $(TOOLS_BASE)$(SEP)
TOOLS_INT = $(INTERMEDIATE_)$(TOOLS_BASE)
TOOLS_INT_ = $(TOOLS_INT)$(SEP)
TOOLS_OUT = $(OUTPUT_)$(TOOLS_BASE)
TOOLS_OUT_ = $(TOOLS_OUT)$(SEP)
$(TOOLS_BASE_DIR_EXISTS): $(INTERMEDIATE_EXISTS) $(RMKDIR_TARGET)
${mkdir} $(TOOLS_BASE_DIR)
@echo . >$@
$(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

180
reactos/tools/unicode/unicode.mak
View file

@ -1,15 +1,22 @@
UNICODE_BASE = $(TOOLS_BASE)$(SEP)unicode
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_BASE_DIR = $(INTERMEDIATE)$(UNICODE_BASE)
UNICODE_BASE_DIR_EXISTS = $(UNICODE_BASE_DIR)$(SEP)$(EXISTS)
$(UNICODE_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(UNICODE_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(UNICODE_BASE_DIR)
@echo . >$(UNICODE_BASE_DIR_EXISTS)
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(UNICODE_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
${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 $@

41
reactos/tools/winebuild/winebuild.mak
View file

@ -1,17 +1,24 @@
WINEBUILD_BASE = $(TOOLS_BASE)$(SEP)winebuild
WINEBUILD_BASE_ = $(WINEBUILD_BASE)$(SEP)
WINEBUILD_INT = $(INTERMEDIATE_)$(WINEBUILD_BASE)
WINEBUILD_INT_ = $(WINEBUILD_INT)$(SEP)
WINEBUILD_OUT = $(OUTPUT_)$(WINEBUILD_BASE)
WINEBUILD_OUT_ = $(WINEBUILD_OUT)$(SEP)
WINEBUILD_BASE_DIR = $(INTERMEDIATE)$(WINEBUILD_BASE)
WINEBUILD_BASE_DIR_EXISTS = $(WINEBUILD_BASE_DIR)$(SEP)$(EXISTS)
$(WINEBUILD_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(WINEBUILD_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(WINEBUILD_BASE_DIR)
@echo . > $@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(WINEBUILD_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
@{mkdir} $@
endif
WINEBUILD_TARGET = \
$(WINEBUILD_BASE_DIR)$(SEP)winebuild$(EXEPOSTFIX)
$(EXEPREFIX)$(WINEBUILD_OUT_)winebuild$(EXEPOSTFIX)
WINEBUILD_SOURCES = $(addprefix $(WINEBUILD_BASE)$(SEP), \
WINEBUILD_SOURCES = $(addprefix $(WINEBUILD_BASE_), \
import.c \
main.c \
parser.c \
@ -32,39 +39,39 @@ WINEBUILD_HOST_LFLAGS = -g
.PHONY: winebuild
winebuild: $(WINEBUILD_TARGET)
$(WINEBUILD_TARGET): $(WINEBUILD_OBJECTS)
$(WINEBUILD_TARGET): $(WINEBUILD_OBJECTS) $(WINEBUILD_OUT)
$(ECHO_LD)
${host_gcc} $(WINEBUILD_OBJECTS) $(WINEBUILD_HOST_LFLAGS) -o $@
$(WINEBUILD_BASE_DIR)$(SEP)import.o: $(WINEBUILD_BASE)$(SEP)import.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)import.o: $(WINEBUILD_BASE_)import.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@
$(WINEBUILD_BASE_DIR)$(SEP)main.o: $(WINEBUILD_BASE)$(SEP)main.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)main.o: $(WINEBUILD_BASE_)main.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@
$(WINEBUILD_BASE_DIR)$(SEP)parser.o: $(WINEBUILD_BASE)$(SEP)parser.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)parser.o: $(WINEBUILD_BASE_)parser.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@
$(WINEBUILD_BASE_DIR)$(SEP)res16.o: $(WINEBUILD_BASE)$(SEP)res16.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)res16.o: $(WINEBUILD_BASE_)res16.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@
$(WINEBUILD_BASE_DIR)$(SEP)res32.o: $(WINEBUILD_BASE)$(SEP)res32.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)res32.o: $(WINEBUILD_BASE_)res32.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@
$(WINEBUILD_BASE_DIR)$(SEP)spec32.o: $(WINEBUILD_BASE)$(SEP)spec32.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)spec32.o: $(WINEBUILD_BASE_)spec32.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@
$(WINEBUILD_BASE_DIR)$(SEP)utils.o: $(WINEBUILD_BASE)$(SEP)utils.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)utils.o: $(WINEBUILD_BASE_)utils.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@
$(WINEBUILD_BASE_DIR)$(SEP)mkstemps.o: $(WINEBUILD_BASE)$(SEP)mkstemps.c $(WINEBUILD_BASE_DIR_EXISTS)
$(WINEBUILD_INT_)mkstemps.o: $(WINEBUILD_BASE_)mkstemps.c $(WINEBUILD_INT)
$(ECHO_CC)
${host_gcc} $(WINEBUILD_HOST_CFLAGS) -c $< -o $@

45
reactos/tools/wmc/wmc.mak
View file

@ -1,17 +1,24 @@
WMC_BASE = $(TOOLS_BASE)$(SEP)wmc
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_BASE_DIR = $(INTERMEDIATE)$(WMC_BASE)
WMC_BASE_DIR_EXISTS = $(WMC_BASE_DIR)$(SEP)$(EXISTS)
$(WMC_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(WMC_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(WMC_BASE_DIR)
@echo . >$@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(WMC_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
${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 $@

46
reactos/tools/wpp/wpp.mak
View file

@ -1,47 +1,55 @@
WPP_BASE = $(TOOLS_BASE)$(SEP)wpp
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_BASE_DIR = $(INTERMEDIATE)$(WPP_BASE)
WPP_BASE_DIR_EXISTS = $(WPP_BASE_DIR)$(SEP)$(EXISTS)
$(WPP_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(WPP_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(WPP_BASE_DIR)
@echo . > $@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(WPP_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
${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 $@

74
reactos/tools/wrc/wrc.mak
View file

@ -1,27 +1,41 @@
WRC_BASE = $(TOOLS_BASE)$(SEP)wrc
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_BASE_DIR = $(INTERMEDIATE)$(WRC_BASE)
WRC_BASE_DIR_EXISTS = $(WRC_BASE_DIR)$(SEP)$(EXISTS)
$(WRC_BASE_DIR_EXISTS): $(TOOLS_BASE_DIR_EXISTS)
$(WRC_INT): $(TOOLS_INT)
$(ECHO_MKDIR)
${mkdir} $(WRC_BASE_DIR)
@echo . > $@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(WRC_OUT): $(TOOLS_OUT)
$(ECHO_MKDIR)
${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_BASE_DIR_EXISTS): $(WRC_BASE_DIR_EXISTS)
$(WRC_PORT_INT): $(WRC_INT)
$(ECHO_MKDIR)
${mkdir} $(WRC_PORT_BASE_DIR)
@echo . > $@
${mkdir} $@
ifneq ($(INTERMEDIATE),$(OUTPUT))
$(WRC_PORT_OUT): $(WRC_OUT)
$(ECHO_MKDIR)
${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 $@