added forced target

fpc/Makefile

@@ -8,11 +8,14 @@ TIER2_OBJS := $(TIER2_FILES:.cpp=.o)
 FPC_FILES := library/helper.cpp library/target.cpp library/builder.cpp library/runner.cpp library/c.cpp library/ld.cpp library/clang/c.cpp library/clang/ld.cpp
 CC = clang
 
-
+ifneq ($(FPC_ARCH),)
-ifeq ($(TARGET),)
+ifneq ($(FPC_OS),)
-REAL_TARGET :=
+ifneq ($(FPC_ABI),)
+REAL_TARGET := -target $(FPC_ARCH)-$(FPC_OS)-$(FPC_ABI) -DFPC_ARCH=\"$(FPC_ARCH)\" -DFPC_OS=\"$(FPC_OS)\" -DFPC_ABI=\"$(FPC_ABI)\"
 else
-REAL_TARGET := -target $(TARGET)
+REAL_TARGET := -target $(FPC_ARCH)-$(FPC_OS) -DFPC_ARCH=\"$(FPC_ARCH)\" -DFPC_OS=\"$(FPC_OS)\"
+endif
+endif
 endif
 
 CCFLAGS = $(REAL_TARGET) -g -I../public -Ipublic

fpc/library/target.cpp

@@ -33,8 +33,12 @@ CUtlString Target_t::GetTriplet()
 	triplet.AppendTail("-");
 	if ( kernel == TARGET_KERNEL_UNKNOWN )
 		triplet.AppendTail("unknown-unknown");
-	if ( kernel == TARGET_KERNEL_LINUX )
+	if ( kernel == TARGET_KERNEL_UNKNOWN_LINUX )
 		triplet.AppendTail("unknown-linux");
+	if ( kernel == TARGET_KERNEL_PC_LINUX )
+		triplet.AppendTail("pc-linux");
+	if ( kernel == TARGET_KERNEL_ALPINE_LINUX )
+		triplet.AppendTail("alpine-linux");
 	if ( kernel == TARGET_KERNEL_WINDOWS )
 		triplet.AppendTail("pc-windows");
 	if ( kernel == TARGET_KERNEL_DARWIN )
@@ -60,33 +64,22 @@ CUtlString Target_t::GetTriplet()
 
 const char *Target_t::GetExecutableFileFormat()
 {
-	switch(kernel)
+	if (kernel & TARGET_KERNEL_POSIX)
+		return "";
+
+	if (kernel & TARGET_KERNEL_WINDOWS_DEVICES)
 	{
-	case TARGET_KERNEL_LINUX:
-	case TARGET_KERNEL_ANDROID:
-	case TARGET_KERNEL_DARWIN:
-	case TARGET_KERNEL_IOS:
-		return "%s";
-		break;
-	case TARGET_KERNEL_WINDOWS:
 		return "%s.exe";
-	default:
-		break;
 	}
 	return NULL;
 }
 
 const char *Target_t::GetStaticLibraryFileFormat()
 {
-	switch(kernel)
+	if (kernel & TARGET_KERNEL_POSIX)
-	{
-	case TARGET_KERNEL_LINUX:
-	case TARGET_KERNEL_ANDROID:
-	case TARGET_KERNEL_DARWIN:
-	case TARGET_KERNEL_IOS:
 		return "lib%s.a";
 
-	case TARGET_KERNEL_WINDOWS:
+	if (kernel & TARGET_KERNEL_WINDOWS_DEVICES)
 	{
 		switch(abi)
 		{
@@ -96,25 +89,16 @@ const char *Target_t::GetStaticLibraryFileFormat()
 			return "lib%s.a";
 		}
 	}
-	default:
-		break;
-	}
 	return NULL;
 }
 const char *Target_t::GetDynamicLibraryFileFormat()
 {
-	switch(kernel)
+	if (kernel & TARGET_KERNEL_LINUX_DEVICES)
-	{
-	case TARGET_KERNEL_LINUX:
-	case TARGET_KERNEL_ANDROID:
 		return "lib%s.so";
-	case TARGET_KERNEL_DARWIN:
+	if (kernel & TARGET_KERNEL_APPLE_DEVICES)
+		return "lib%s.dylib";
+	if (kernel & TARGET_KERNEL_WINDOWS_DEVICES)
 		return "lib%s.dylib";
-	case TARGET_KERNEL_WINDOWS:
-		return "%s.dll";
-	default:
-		break;
-	}
 	return NULL;
 }
 //----------------------------------------------------------------------------
@@ -124,25 +108,19 @@ const char *Target_t::GetDynamicLibraryFileFormat()
 //----------------------------------------------------------------------------
 Target_t Target_t::HostTarget()
 {
-	ETargetKernel kernel = 
+	ETargetKernel kernel = TARGET_KERNEL_UNDEFINED;
 #if defined(__linux__)
-	TARGET_KERNEL_LINUX
+	kernel = TARGET_KERNEL_LINUX;
 #elif defined(__APPLE__)
-		TARGET_KERNEL_DARWIN
+	kernel TARGET_KERNEL_DARWIN;
 #endif
-	;
+ETargetCPU cpu = TARGET_CPU_UNDEFINED;
-// i have no idea how to get libc
-	ETargetABI abi = 
-	TARGET_ABI_GNU
-		;
-ETargetCPU cpu = 
 #if defined(__x86_64__)
-	TARGET_CPU_AMD64
+	cpu = TARGET_CPU_AMD64;
 #endif
 #if defined(__i386__)
-	TARGET_CPU_80386
+	cpu = TARGET_CPU_80386;
 #endif
-	;
 // POSIX doesn't know about these
 // use uname to get them
 #if defined(__i386__) && defined(POSIX)
@@ -153,6 +131,18 @@ ETargetCPU cpu =
 	if (!V_strcmp("i686", s_uname.machine))
 		cpu = TARGET_CPU_80686;
 #endif
+	ETargetABI abi = TARGET_ABI_GNU;
+
+#ifdef FPC_ARCH
+	cpu = CPUFromString(FPC_ARCH);
+#endif
+#ifdef FPC_OS
+	kernel = KernelFromString(FPC_OS);
+#endif
+#ifdef FPC_ABI
+	abi = ABIFromString(FPC_ABI);
+#endif
+
 
 	return {
 		.kernel = kernel,
@@ -172,44 +162,16 @@ Target_t Target_t::DefaultTarget()
 	CUtlString szArch = CommandLine()->ParamValue("-arch");
 	CUtlString szAbi = CommandLine()->ParamValue("-abi");
 
-	ETargetKernel kernel = HostTarget().kernel;
+	ETargetKernel kernel = KernelFromString(szOS);
-	ETargetCPU cpu = HostTarget().cpu;
+	ETargetCPU cpu = CPUFromString(szArch);
-	ETargetABI abi = HostTarget().abi;
+	ETargetABI abi = ABIFromString(szAbi);
+	if (cpu == TARGET_CPU_UNDEFINED)
+		cpu = HostTarget().cpu;
+	if (kernel == TARGET_KERNEL_UNDEFINED)
+		kernel = HostTarget().kernel;
+	if (abi == TARGET_ABI_UNDEFINED)
+		abi = HostTarget().abi;
 
-	if ( szArch == "x86_64" )
-		cpu = TARGET_CPU_AMD64;
-	else if ( szArch == "i386" )
-		cpu = TARGET_CPU_80386;
-	else if ( szArch == "i486" )
-		cpu = TARGET_CPU_80486;
-	else if ( szArch == "i586" )
-		cpu = TARGET_CPU_80586;
-	else if ( szArch == "i686" )
-		cpu = TARGET_CPU_80686;
-	else if ( szArch == "aarch64" )
-		cpu = TARGET_CPU_AARCH64;
-	else if ( szArch == "wasm32" )
-		cpu = TARGET_CPU_WASM32;
-
-	if ( szOS == "unknown" )
-		kernel = TARGET_KERNEL_UNKNOWN;
-	else if ( szOS == "windows" )
-		kernel = TARGET_KERNEL_WINDOWS;
-	else if ( szOS == "linux" )
-		kernel = TARGET_KERNEL_LINUX;
-	else if ( szOS == "macos" )
-		kernel = TARGET_KERNEL_DARWIN;
-	else if ( szOS == "ios" )
-		kernel = TARGET_KERNEL_IOS;
-	else if ( szOS == "android" )
-		kernel = TARGET_KERNEL_ANDROID;
-	else if ( szOS != 0 )
-		V_printf("Unknown OS: %s\n", szOS.GetString());
-
-	if ( szAbi == "gnu" )
-		abi = TARGET_ABI_GNU;
-	else if ( szAbi == "musl" )
-		abi = TARGET_ABI_MUSL;
 	
 	return {
 		.kernel = kernel,
@@ -218,3 +180,57 @@ Target_t Target_t::DefaultTarget()
 		.optimization = TARGET_DEBUG,
 	};
 }
+ETargetCPU Target_t::CPUFromString( const char *szName )
+{
+	CUtlString szUtlName = szName;
+	if ( szUtlName == "x86_64" )
+		return TARGET_CPU_AMD64;
+	else if ( szUtlName == "i386" )
+		return TARGET_CPU_80386;
+	else if ( szUtlName == "i486" )
+		return TARGET_CPU_80486;
+	else if ( szUtlName == "i586" )
+		return TARGET_CPU_80586;
+	else if ( szUtlName == "i686" )
+		return TARGET_CPU_80686;
+	else if ( szUtlName == "aarch64" )
+		return TARGET_CPU_AARCH64;
+	else if ( szUtlName == "wasm32" )
+		return TARGET_CPU_WASM32;
+	return TARGET_CPU_UNDEFINED;
+}
+
+ETargetKernel Target_t::KernelFromString( const char *szName )
+{
+	CUtlString szUtlName = szName;
+	if ( szUtlName == "unknown" )
+		return TARGET_KERNEL_UNKNOWN;
+	else if ( szUtlName == "windows" )
+		return TARGET_KERNEL_WINDOWS;
+	else if ( szUtlName == "linux" )
+		return TARGET_KERNEL_LINUX;
+	else if ( szUtlName == "unknown-linux" )
+		return TARGET_KERNEL_UNKNOWN_LINUX;
+	else if ( szUtlName == "pc-linux" )
+		return TARGET_KERNEL_PC_LINUX;
+	else if ( szUtlName == "alpine-linux" )
+		return TARGET_KERNEL_ALPINE_LINUX;
+	else if ( szUtlName == "macos" )
+		return TARGET_KERNEL_DARWIN;
+	else if ( szUtlName == "ios" )
+		return TARGET_KERNEL_IOS;
+	else if ( szUtlName == "android" )
+		return TARGET_KERNEL_ANDROID;
+	return TARGET_KERNEL_UNDEFINED;
+}
+
+ETargetABI Target_t::ABIFromString( const char *szName )
+{
+	CUtlString szUtlName = szName;
+	if ( szUtlName == "gnu" )
+		return TARGET_ABI_GNU;
+	else if ( szUtlName == "musl" )
+		return TARGET_ABI_MUSL;
+	return TARGET_ABI_UNDEFINED;
+}
+

fpc/public/target.h

@@ -10,15 +10,20 @@
 
 enum ETargetKernel
 {
-	TARGET_KERNEL_UNKNOWN = 0,
+	TARGET_KERNEL_UNDEFINED,
+	TARGET_KERNEL_UNKNOWN = 1,
 
 	TARGET_KERNEL_WINDOWS_DEVICES = 0x100,
 	TARGET_KERNEL_WINDOWS,
 
 	TARGET_KERNEL_POSIX = 0x10000,
-	TARGET_KERNEL_LINUX,
+	TARGET_KERNEL_LINUX_DEVICES = TARGET_KERNEL_POSIX | 0x1000,
+	TARGET_KERNEL_UNKNOWN_LINUX,
+	TARGET_KERNEL_LINUX = TARGET_KERNEL_UNKNOWN_LINUX,
+	TARGET_KERNEL_ALPINE_LINUX,
+	TARGET_KERNEL_PC_LINUX,
 	TARGET_KERNEL_ANDROID,
-	TARGET_KERNEL_APPLE_DEVICES = TARGET_KERNEL_POSIX | 0x200,
+	TARGET_KERNEL_APPLE_DEVICES = TARGET_KERNEL_POSIX | 0x2000,
 	TARGET_KERNEL_DARWIN,
 	TARGET_KERNEL_IOS,
 
@@ -29,16 +34,18 @@ enum ETargetKernel
 
 enum ETargetCPU
 {
-	TARGET_CPU_AMD64,
+	TARGET_CPU_UNDEFINED,
 	TARGET_CPU_80386,
 	TARGET_CPU_80486,
 	TARGET_CPU_80586,
 	TARGET_CPU_80686,
+	TARGET_CPU_AMD64,
 	TARGET_CPU_AARCH64,
 	TARGET_CPU_WASM32,
 };
 enum ETargetABI
 {
+	TARGET_ABI_UNDEFINED,
 	TARGET_ABI_DEFAULT,
 	TARGET_ABI_GNU,
 	TARGET_ABI_MUSL,
@@ -66,6 +73,9 @@ struct Target_t
 	const char *GetDynamicLibraryFileFormat();
 	static Target_t HostTarget();
 	static Target_t DefaultTarget();
+	static ETargetCPU CPUFromString( const char *szName );
+	static ETargetKernel KernelFromString( const char *szName );
+	static ETargetABI ABIFromString( const char *szName );
 };
 
 enum EShaderTarget

tier0/platform.cpp

@@ -18,6 +18,7 @@
 #endif
 #ifdef __WIN32__
 #include "windows.h"
+#include "direct.h"
 #endif
 
 PLATFORM_INTERFACE void Plat_FatalErrorFunc(const char* szFormat, ...)
@@ -121,10 +122,15 @@ PLATFORM_INTERFACE char *Plat_GetExtension( const char *szPath )
 }
 PLATFORM_INTERFACE void Plat_MakeDir( const char *szPath, int iPermissions )
 {
+#ifdef __WIN32__
+	_mkdir(szPath);
+#endif
+#ifdef POSIX
 #ifndef ACCESSPERMS
 #define ACCESSPERMS 0777
 #endif
 	mkdir(szPath, ACCESSPERMS);
+#endif
 }
 
 PLATFORM_INTERFACE void Plat_Backtrace( void )
@@ -210,7 +216,12 @@ PLATFORM_INTERFACE void *Plat_GetProc( void *lib, const char *psz )
 
 PLATFORM_INTERFACE void Plat_SetEnv( const char *szVar, const char *psz )
 {
+#ifdef POSIX
 	setenv(szVar, psz, true);
+#endif
+#ifdef __WIN32__
+	SetEnvironmentVariable(szVar, psz);
+#endif
 }
 
 PLATFORM_INTERFACE const char *Plat_GetEnv( const char *szVar )