kotofyt/funnygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

no engine anymore

Browse Source
This commit is contained in:
kotofyt
2025-07-30 23:53:26 +03:00
parent 8a29e6b86f
commit 395ced9e28
159 changed files with 2767 additions and 9484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
fpc/library/android/apktool.cpp Normal file
View File

@@ -0,0 +1,139 @@
#include "apktool.h"
#include "helper.h"
#include "tier0/lib.h"
#include "tier0/platform.h"
#include "tier1/commandline.h"
#include "tier1/interface.h"
#include "runner.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
void AndroidManifest_t::SetPackageVersion( CUtlString szVersion )
{
m_szVersion = szVersion;
}
void AndroidManifest_t::SetPackageBuild( uint64_t nBuild )
{
m_nBuild = nBuild;
}
void AndroidManifest_t::SetPackageID( CUtlString szPackageID )
{
m_szPackageID = szPackageID;
}
void AndroidManifest_t::SetPackageName( CUtlString szPackageName )
{
m_szPackageName = szPackageName;
}
void AndroidManifest_t::SetTargetSDKVersion( uint64_t nTargetVersion )
{
m_nTargetVersion = nTargetVersion;
}
void AndroidManifest_t::SetMinSDKVersion( uint64_t nMinVersion )
{
m_nMinVersion = nMinVersion;
}
void AndroidManifest_t::AddUserFeature( CUtlString szName, bool bIsRequired, uint64_t nVersion )
{
}
void AndroidManifest_t::AddUserLibrary( CUtlString szPath )
{
}
CUtlString AndroidManifest_t::BuildManifest()
{
CPUProject_t project = {};
project.m_szName = m_szPackageName;
unsigned int hash = project.GenerateProjectHash();
CUtlString szOutputDir = CUtlString("%s/%s/android/%u_%s/",FPC_TEMPORAL_DIRNAME, project.m_target.GetTriplet().GetString(), hash, m_szPackageID.GetString());
filesystem2->MakeDirectory(szOutputDir);
filesystem2->MakeDirectory(CUtlString("%s/res", szOutputDir.GetString()));
CUtlString szAndroidManifestPath = CUtlString("%s/AndroidManifest.xml", szOutputDir.GetString());
FILE *pAndroidManifest = V_fopen(szAndroidManifestPath, "wb");
V_fprintf(pAndroidManifest, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
V_fprintf(pAndroidManifest, "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\" package=\"%s\">\n", m_szPackageID.GetString());
V_fprintf(pAndroidManifest, "<uses-sdk android:minSdkVersion=\"%lu\" android:targetSdkVersion=\"%lu\" />\n",m_nMinVersion, m_nTargetVersion);
V_fprintf(pAndroidManifest, "<application android:label=\"%s\" android:hasCode=\"false\" android:debuggable=\"true\">\n", m_szPackageName.GetString());
V_fprintf(pAndroidManifest, "<activity android:name=\"android.app.NativeActivity\" android:label=\"%s\" android:exported=\"true\">\n", m_szPackageName.GetString());
V_fprintf(pAndroidManifest, "<meta-data android:name=\"android.app.lib_name\" android:value=\"native-app\" />\n");
V_fprintf(pAndroidManifest, "<intent-filter>\n");
V_fprintf(pAndroidManifest, "<action android:name=\"android.intent.action.MAIN\" />\n");
V_fprintf(pAndroidManifest, "<category android:name=\"android.intent.category.LAUNCHER\" />\n");
V_fprintf(pAndroidManifest, "</intent-filter>\n");
V_fprintf(pAndroidManifest, "</activity>\n");
V_fprintf(pAndroidManifest, "</application>\n");
V_fprintf(pAndroidManifest, "</manifest>\n");
V_fclose(pAndroidManifest);
return szOutputDir;
};
class CAPKTool : public IAPKTool
{
public:
virtual CUtlString BuildPackage( AndroidManifest_t manifest, CUtlString szManifestDir ) override;
private:
};
CUtlString CAPKTool::BuildPackage( AndroidManifest_t manifest, CUtlString szManifestDir )
{
V_printf(" APKTOOL %s\n", manifest.m_szPackageID.GetString());
if (CommandLine()->ParamValue("-android_build_tools"))
{
CUtlVector<CUtlString> args = {
"package",
"-f",
"-M",
"AndroidManifest.xml",
"-S",
"res",
"-I",
CUtlString("%s/../../platforms/android-%lu/android.jar", CommandLine()->ParamValue("-android_build_tools"), manifest.m_nTargetVersion),
"-F",
CUtlString("%s.unaligned.apk", manifest.m_szPackageID.GetString()),
};
CUtlString szAndroidSDK = CommandLine()->ParamValue("-android_build_tools");
runner->Run(CUtlString("%s/aapt",szAndroidSDK.GetString()),szManifestDir,args);
runner->Wait();
args = {
"-u",
CUtlString("%s.unaligned.apk", manifest.m_szPackageID.GetString()),
"lib/x86_64/libnative-app.so",
};
runner->Run("zip",szManifestDir, args);
runner->Wait();
args = {
"-f",
"-v",
"4",
CUtlString("%s.unaligned.apk", manifest.m_szPackageID.GetString()),
CUtlString("%s.apk", manifest.m_szPackageID.GetString()),
};
runner->Run(CUtlString("%s/zipalign",szAndroidSDK.GetString()),szManifestDir,args);
} else
Plat_FatalErrorFunc("-android_build_tools was not specified.");
return 0;
}
IAPKTool *APKTool()
{
static CAPKTool s_apktool = {};
return &s_apktool;
}

23
fpc/library/android/signtool.cpp Normal file
View File

@@ -0,0 +1,23 @@
#include "signtool.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
class CAndroidSignTool : public ISignTool
{
public:
virtual void SignFile( CUtlString szFile ) override;
virtual void SignDirectory( CUtlString szDirectory ) override;
};
EXPOSE_INTERFACE(CAndroidSignTool, ISignTool, ANDROID_SIGN_TOOL_INTERFACE_NAME);
void CAndroidSignTool::SignFile( CUtlString szFile )
{
}
void CAndroidSignTool::SignDirectory( CUtlString szDirectory )
{
V_printf("Android doesn't support signing of directories\n");
}

122
fpc/library/c.cpp
View File

@@ -1,123 +1,3 @@
#include "c.h"
#include "filesystem.h"
#include "helper.h"
#include "target.h"
#include "tier0/lib.h"
#include "tier0/platform.h"
#include "tier1/utlvector.h"
#include "libgen.h"
#include "ctype.h"
struct ClangFile_t
{
CUtlString m_szName;
CUtlVector<CUtlString> m_szArguments;
};
CUtlVector<ClangFile_t> g_clangFiles;
CLDProject CCProject::Compile()
{
CLDProject proj = {};
proj.m_szName = m_szName;
unsigned int hash = GenerateProjectHash();
for (auto &file: files)
{
CUtlString szTarget = m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, m_szName.GetString(), IFileSystem2::BuildDirectory(), file.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
IFileSystem2::MakeDirectory(szOutputDir);
}
for (auto &file: files)
{
CUtlVector<CUtlString> args;
V_printf(" CC %s\n", file.GetString());
CUtlString szTarget = m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, m_szName.GetString(), IFileSystem2::BuildDirectory(), file.GetString());
args = {
"-target",
szTarget,
"-g",
"-c",
"-o",
szOutputFile,
file,
};
if (!strcmp(Plat_GetExtension(file),"cpp"))
args.AppendTail("-std=c++17");
else if (!strcmp(Plat_GetExtension(file),"mm"))
;
else
args.AppendTail("-std=c99");
if (m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
}
if (m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
}
if (bFPIC)
args.AppendTail("-fPIC");
if (bFPIE)
args.AppendTail("-fPIE");
for (auto &macro: macros)
{
args.AppendTail("-D");
args.AppendTail(CUtlString("%s=%s", (char*)macro.szName, (char*)macro.szValue));
}
for (auto &include: includeDirectories)
{
args.AppendTail("-I");
args.AppendTail(include);
}
for (auto &include: includeFiles)
{
args.AppendTail("-include");
args.AppendTail(include);
}
if (!IFileSystem2::ShouldRecompile(file, szOutputFile))
goto skipcompile;
IRunner::Run("clang", args);
skipcompile:
proj.objects.AppendTail((CObject){szOutputFile});
ClangFile_t cfile = {};
cfile.m_szName = file;
cfile.m_szArguments = args;
g_clangFiles.AppendTail(cfile);
}
return proj;
}
void CCProject::GenerateCompileCommands()
{
FILE* f = V_fopen("compile_commands.json", "w");
V_fprintf(f, "[\n");
uint32_t i = 0;
for (auto &file: g_clangFiles)
{
V_fprintf(f, "\t{\n");
V_fprintf(f, "\t\t\"arguments\": [\n");
V_fprintf(f, "\t\t\t\"clang\",\n");
for (auto &arg: file.m_szArguments)
V_fprintf(f, "\t\t\t\"%s\",\n",arg.GetString());
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n\t\t],\n");
V_fprintf(f, "\t\t\"file\": \"%s\",\n", file.m_szName.GetString());
V_fprintf(f, "\t\t\"directory\": \"%s\"\n", IFileSystem2::BuildDirectory());
V_fprintf(f, "\t},\n");
};
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n]\n");
V_fclose(f);
};
ICCompiler *ccompiler;

164
fpc/library/clang/c.cpp Normal file
View File

@@ -0,0 +1,164 @@
#include "c.h"
#include "helper.h"
#include "obj.h"
#include "target.h"
#include "tier0/lib.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#include "libgen.h"
#include "ctype.h"
struct ClangFile_t
{
CUtlString m_szName;
CUtlVector<CUtlString> m_szArguments;
};
class CClangCompiler : public ICCompiler
{
public:
virtual LinkProject_t Compile( CProject_t *pProject ) override;
virtual void GenerateLinterData( void ) override;
};
EXPOSE_INTERFACE(CClangCompiler, ICCompiler, CLANG_C_COMPILER_INTERFACE_NAME);
CUtlVector<ClangFile_t> g_clangFiles;
LinkProject_t CClangCompiler::Compile( CProject_t *pProject )
{
LinkProject_t proj = {};
proj.m_szName = pProject->m_szName;
proj.m_target = pProject->m_target;
proj.m_androidmanifest = pProject->m_androidmanifest;
unsigned int hash = pProject->GenerateProjectHash();
for (auto &file: pProject->files)
{
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, pProject->m_szName.GetString(), filesystem2->BuildDirectory(), file.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
filesystem2->MakeDirectory(szOutputDir);
}
for (auto &file: pProject->files)
{
CUtlVector<CUtlString> args;
V_printf(" CC %s\n", file.GetString());
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szCompiledTarget = szTarget;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
szCompiledTarget = CUtlString("%s%u", szTarget.GetString(), pProject->m_androidmanifest.m_nTargetVersion);
}
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, pProject->m_szName.GetString(), filesystem2->BuildDirectory(), file.GetString());
args = {
"-target",
szCompiledTarget,
"-g",
"-c",
"-o",
szOutputFile,
file,
};
if (!strcmp(Plat_GetExtension(file),"cpp"))
args.AppendTail("-std=c++17");
else if (!strcmp(Plat_GetExtension(file),"mm"))
;
else
args.AppendTail("-std=c99");
if (pProject->m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
} else if (pProject->m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
}
if (pProject->m_target.szSysroot)
{
args.AppendTail(CUtlString("--sysroot=%s", pProject->m_target.szSysroot));
}
if (pProject->bFPIC)
args.AppendTail("-fPIC");
if (pProject->bFPIE)
args.AppendTail("-fPIE");
for (auto &macro: pProject->macros)
{
args.AppendTail("-D");
args.AppendTail(CUtlString("%s=%s", (char*)macro.szName, (char*)macro.szValue));
}
for (auto &include: pProject->includeDirectories)
{
args.AppendTail("-I");
args.AppendTail(include);
}
for (auto &include: pProject->includeFiles)
{
args.AppendTail("-include");
args.AppendTail(include);
}
if (!filesystem2->ShouldRecompile(file, szOutputFile))
goto skipcompile;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
if (!pProject->m_target.szSysroot)
Plat_FatalErrorFunc("-sysroot must be specified for android\n");
runner->Run(CUtlString("%s/bin/clang",pProject->m_target.szSysroot), args);
}
else
{
runner->Run("clang", args);
}
skipcompile:
proj.objects.AppendTail((Object_t){szOutputFile});
ClangFile_t cfile = {};
cfile.m_szName = file;
cfile.m_szArguments = args;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
if (!pProject->m_target.szSysroot)
Plat_FatalErrorFunc("-sysroot must be specified for android\n");
cfile.m_szArguments.AppendHead(CUtlString("%s/bin/clang",pProject->m_target.szSysroot));
}
else
cfile.m_szArguments.AppendHead("clang");
g_clangFiles.AppendTail(cfile);
}
return proj;
}
void CClangCompiler::GenerateLinterData()
{
FILE* f = V_fopen("compile_commands.json", "wb");
V_fprintf(f, "[\n");
uint32_t i = 0;
for (auto &file: g_clangFiles)
{
V_fprintf(f, "\t{\n");
V_fprintf(f, "\t\t\"arguments\": [\n");
for (auto &arg: file.m_szArguments)
V_fprintf(f, "\t\t\t\"%s\",\n",arg.GetString());
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n\t\t],\n");
V_fprintf(f, "\t\t\"file\": \"%s\",\n", file.m_szName.GetString());
V_fprintf(f, "\t\t\"directory\": \"%s\"\n", filesystem2->BuildDirectory());
V_fprintf(f, "\t},\n");
};
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n]\n");
V_fclose(f);
};

175
fpc/library/clang/ld.cpp Normal file
View File

@@ -0,0 +1,175 @@
#include "ld.h"
#include "helper.h"
#include "libgen.h"
#include "target.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
#include "tier1/utlstring.h"
class CClangLinker : public ILinker
{
public:
virtual CUtlString Link( LinkProject_t *pProject ) override;
};
EXPOSE_INTERFACE(CClangLinker, ILinker, CLANG_LINKER_INTERFACE_NAME);
CUtlString CClangLinker::Link( LinkProject_t *pProject )
{
CUtlString szFileName;
unsigned int hash = pProject->GenerateProjectHash();
switch(pProject->linkType)
{
case ELINK_EXECUTABLE:
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS)
szFileName = CUtlString("%s.exe", pProject->m_szName.GetString());
else if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
szFileName = CUtlString("lib%s.so", pProject->m_szName.GetString());
else
szFileName = CUtlString("%s", pProject->m_szName.GetString());
break;
case ELINK_STATIC_LIBRARY:
szFileName = CUtlString("lib%s.a", pProject->m_szName.GetString());
break;
case ELINK_DYNAMIC_LIBRARY:
if (pProject->m_target.kernel == TARGET_KERNEL_DARWIN)
szFileName = CUtlString("lib%s.dylib", pProject->m_szName.GetString());
if (pProject->m_target.kernel == TARGET_KERNEL_LINUX)
szFileName = CUtlString("lib%s.so", pProject->m_szName.GetString());
break;
}
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/ld/%u_%s/%s",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, pProject->m_szName.GetString(), szFileName.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
filesystem2->MakeDirectory(szOutputDir);
if (pProject->linkType == ELINK_STATIC_LIBRARY)
{
V_printf(" AR %s\n", pProject->m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: pProject->objects)
{
if (filesystem2->ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
args = {
"rcs",
szOutputFile
};
for (auto object: pProject->objects)
args.AppendTail(object.m_szObjectFile);
runner->Run("ar", args);
runner->Wait();
} else {
V_printf(" LINK %s\n", pProject->m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: pProject->objects)
{
if (filesystem2->ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szCompiledTarget = szTarget;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
szCompiledTarget = CUtlString("%s%u", szTarget.GetString(), pProject->m_androidmanifest.m_nTargetVersion);
}
args = {
"-o",
szOutputFile,
"-target",
szCompiledTarget,
};
if (pProject->bNoStdLib)
{
args.AppendTail("-nostdlib");
}
if (pProject->m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
args.AppendTail("-Wl,-export_dynamic");
args.AppendTail("-undefined");
args.AppendTail("dynamic_lookup");
}
else if (pProject->m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
args.AppendTail("-Wl,-rpath,@executable_path");
args.AppendTail("-Wl,-all_load");
args.AppendTail("-w");
}
else if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
args.AppendTail(CUtlString("--sysroot=%s/sysroot", pProject->m_target.szSysroot));
args.AppendTail("-static-libstdc++");
}
else if (pProject->m_target.szSysroot)
{
args.AppendTail(CUtlString("--sysroot=%s", pProject->m_target.szSysroot));
}
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS)
{
args.AppendTail("-fuse-ld=ld");
}
if (pProject->m_target.kernel == TARGET_KERNEL_LINUX || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
args.AppendTail("-rdynamic");
}
if (pProject->linkType == ELINK_DYNAMIC_LIBRARY || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
args.AppendTail("-shared");
}
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS || pProject->m_target.kernel == TARGET_KERNEL_LINUX || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
args.AppendTail("-Wl,--whole-archive");
for (auto object: pProject->objects)
args.AppendTail(object.m_szObjectFile);
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS || pProject->m_target.kernel == TARGET_KERNEL_LINUX || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
args.AppendTail("-Wl,--no-whole-archive");
for (auto lib: pProject->libraries)
{
args.AppendTail("-l");
args.AppendTail(lib);
}
for (auto &directory: pProject->frameworkDirectories)
{
args.AppendTail("-F");
args.AppendTail(directory);
}
for (auto &framework: pProject->frameworks)
{
args.AppendTail("-framework");
args.AppendTail(framework);
}
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
if (!pProject->m_target.szSysroot)
Plat_FatalErrorFunc("-sysroot must be specified for android\n");
runner->Run(CUtlString("%s/bin/clang++",pProject->m_target.szSysroot), args);
}
else
{
runner->Run("clang++", args);
}
runner->Wait();
}
compiled:
return szOutputFile;
};

0
fpc/library/generator/makefile.cpp Normal file
View File

50
fpc/library/helper.cpp
View File

@@ -6,12 +6,13 @@
#include "unistd.h"
#include "libgen.h"
#include "sys/stat.h"
#include "tier1/interface.h"
#ifdef __APPLE__
#include <mach-o/dyld.h>
#endif
unsigned int g_hashState = 102851263;
unsigned int CProject::GenerateProjectHash( void )
unsigned int BaseProject_t::GenerateProjectHash( void )
{
unsigned int hash = 5381+g_hashState;
int c;
@@ -31,50 +32,65 @@ static ssize_t pathSize = readlink("/proc/self/exe", path, sizeof(path) - 1);
#endif
#ifdef __APPLE__
static uint32_t pathSize = sizeof(path);
int pathResult = _NSGetExecutablePath(path, &pathSize);
static int pathResult = _NSGetExecutablePath(path, &pathSize);
#endif
char *szPathDir = dirname(path);
char *szBuildDir = 0;
char *IFileSystem2::OwnDirectory()
static char *szPathDir = dirname(path);
char *g_szBuildDir = 0;
class CPOSIXFileSystem2: public IFileSystem2
{
public:
virtual char *OwnDirectory() override;
virtual char *BuildDirectory() override;
virtual void MakeDirectory( const char *psz ) override;
virtual void CopyFile( const char *szDestination, const char *szOrigin ) override;
virtual void CopyDirectory( const char *szDestination, const char *szOrigin ) override;
virtual bool ShouldRecompile( const char *szSource, const char *szOutput ) override;
};
EXPOSE_INTERFACE(CPOSIXFileSystem2, IFileSystem2, FILE_SYSTEM_2_INTERFACE_NAME);
IFileSystem2 *filesystem2;
char *CPOSIXFileSystem2::OwnDirectory()
{
return szPathDir;
};
char *IFileSystem2::BuildDirectory()
char *CPOSIXFileSystem2::BuildDirectory()
{
return szBuildDir;
return g_szBuildDir;
};
void IFileSystem2::CopyFile( const char *szDestination, const char *szOrigin )
void CPOSIXFileSystem2::CopyFile( const char *szDestination, const char *szOrigin )
{
CUtlVector<CUtlString> args = {
CUtlString(szOrigin),
CUtlString(szDestination),
};
IRunner::Run("cp", args);
IRunner::Wait();
runner->Run("cp", args);
runner->Wait();
}
void IFileSystem2::CopyDirectory( const char *szDestination, const char *szOrigin )
void CPOSIXFileSystem2::CopyDirectory( const char *szDestination, const char *szOrigin )
{
CUtlVector<CUtlString> args = {
"-r",
CUtlString(szOrigin),
CUtlString(szDestination),
};
IRunner::Run("cp", args);
IRunner::Wait();
runner->Run("cp", args);
runner->Wait();
}
void IFileSystem2::MakeDirectory( const char *psz )
void CPOSIXFileSystem2::MakeDirectory( const char *psz )
{
CUtlVector<CUtlString> args = {
"-p",
CUtlString(psz),
};
IRunner::Run("mkdir", args);
IRunner::Wait();
runner->Run("mkdir", args);
runner->Wait();
};
bool IFileSystem2::ShouldRecompile(const char *szSource, const char *szOutput)
bool CPOSIXFileSystem2::ShouldRecompile(const char *szSource, const char *szOutput)
{
struct stat srcbuf;
struct stat outbuf;

133
fpc/library/ld.cpp
View File

@@ -1,134 +1,3 @@
#include "ld.h"
#include "helper.h"
#include "libgen.h"
#include "target.h"
CUtlString CLDProject::Link( void )
{
CUtlString szFileName;
unsigned int hash = GenerateProjectHash();
switch(linkType)
{
case ELINK_EXECUTABLE:
if (m_target.kernel == TARGET_KERNEL_WINDOWS)
szFileName = CUtlString("%s.exe", m_szName.GetString());
else
szFileName = CUtlString("%s", m_szName.GetString());
break;
case ELINK_STATIC_LIBRARY:
szFileName = CUtlString("lib%s.a", m_szName.GetString());
break;
case ELINK_DYNAMIC_LIBRARY:
if (m_target.kernel == TARGET_KERNEL_DARWIN)
szFileName = CUtlString("lib%s.dylib", m_szName.GetString());
if (m_target.kernel == TARGET_KERNEL_LINUX)
szFileName = CUtlString("lib%s.so", m_szName.GetString());
break;
}
CUtlString szTarget = m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/ld/%u_%s/%s",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, m_szName.GetString(), szFileName.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
IFileSystem2::MakeDirectory(szOutputDir);
if (linkType == ELINK_STATIC_LIBRARY)
{
V_printf(" AR %s\n", m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: objects)
{
if (IFileSystem2::ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
args = {
"rcs",
szOutputFile
};
for (auto object: objects)
args.AppendTail(object.m_szObjectFile);
IRunner::Run("ar", args);
IRunner::Wait();
} else {
V_printf(" LINK %s\n", m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: objects)
{
if (IFileSystem2::ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
args = {
"-o",
szOutputFile,
"-target",
m_target.GetTriplet(),
};
if (m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
args.AppendTail("-Wl,-export_dynamic");
args.AppendTail("-undefined");
args.AppendTail("dynamic_lookup");
}
if (m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
args.AppendTail("-Wl,-rpath,@executable_path");
args.AppendTail("-Wl,-all_load");
args.AppendTail("-w");
}
if (m_target.kernel == TARGET_KERNEL_WINDOWS)
{
args.AppendTail("-fuse-ld=ld");
}
if (m_target.kernel == TARGET_KERNEL_LINUX)
{
args.AppendTail("-rdynamic");
}
if (linkType == ELINK_DYNAMIC_LIBRARY)
{
args.AppendTail("-shared");
}
if (m_target.kernel == TARGET_KERNEL_WINDOWS || m_target.kernel == TARGET_KERNEL_LINUX)
args.AppendTail("-Wl,--whole-archive");
for (auto object: objects)
args.AppendTail(object.m_szObjectFile);
if (m_target.kernel == TARGET_KERNEL_WINDOWS || m_target.kernel == TARGET_KERNEL_LINUX)
args.AppendTail("-Wl,--no-whole-archive");
for (auto lib: libraries)
{
args.AppendTail("-l");
args.AppendTail(lib);
}
for (auto &directory: frameworkDirectories)
{
args.AppendTail("-F");
args.AppendTail(directory);
}
for (auto &framework: frameworks)
{
args.AppendTail("-framework");
args.AppendTail(framework);
}
IRunner::Run("clang++", args);
IRunner::Wait();
}
compiled:
return szOutputFile;
};
ILinker *linker;

34
fpc/library/runner.cpp
View File

@@ -1,5 +1,6 @@
#include "runner.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#include "unistd.h"
@@ -7,7 +8,20 @@
#include "tier1/commandline.h"
CUtlVector<pid_t> g_processes;
int IRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
class CPOSIXRunner: public IRunner
{
public:
virtual int Run( CUtlString szName, CUtlVector<CUtlString>& args ) override;
virtual int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args ) override;
virtual int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment ) override;
virtual int Wait( void ) override;
};
EXPOSE_INTERFACE(CPOSIXRunner, IRunner, RUNNER_INTERFACE_NAME);
IRunner *runner;
int CPOSIXRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
{
pid_t pid = fork();
if (pid < 0)
@@ -17,15 +31,15 @@ int IRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
{
CUtlVector<const char*> execargs;
execargs.AppendTail(szName);
if (ICommandLine::CheckParam("-fpcdebug"))
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("%s",szName.GetString());
for (auto &arg: args)
{
execargs.AppendTail(arg);
if (ICommandLine::CheckParam("-fpcdebug"))
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf(" %s",arg.GetString());
}
if (ICommandLine::CheckParam("-fpcdebug"))
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("\n");
execargs.AppendTail(0);
if ( execvp(szName, (char *const*)execargs.GetData()) == -1 )
@@ -38,7 +52,7 @@ int IRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
return 0;
}
int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args)
int CPOSIXRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args)
{
pid_t pid = fork();
if (pid < 0)
@@ -48,10 +62,16 @@ int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlStrin
{
CUtlVector<const char*> execargs;
execargs.AppendTail(szName);
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("%s",szName.GetString());
for (auto &arg: args)
{
execargs.AppendTail(arg);
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf(" %s",arg.GetString());
}
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("\n");
execargs.AppendTail(0);
chdir(szDirectory.GetString());
if ( execvp(szName, (char *const*)execargs.GetData()) == -1 )
@@ -65,12 +85,12 @@ int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlStrin
return 0;
}
int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment)
int CPOSIXRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment)
{
}
int IRunner::Wait( void )
int CPOSIXRunner::Wait( void )
{
for (auto &process: g_processes)
{

36
fpc/library/target.cpp
View File

@@ -1,8 +1,10 @@
#include "target.h"
#include "tier1/commandline.h"
#include "tier1/utlstring.h"
//-----------------------------------------------------------------------------
// Generates triplet suitable for most compilers.
//-----------------------------------------------------------------------------
CUtlString Target_t::GetTriplet()
{
CUtlString triplet = "";
@@ -11,15 +13,25 @@ CUtlString Target_t::GetTriplet()
triplet.AppendTail("x86_64");
if ( cpu == TARGET_CPU_AARCH64 )
triplet.AppendTail("aarch64");
if ( cpu == TARGET_CPU_WASM32 )
triplet.AppendTail("wasm32");
triplet.AppendTail("-");
if ( kernel == TARGET_KERNEL_WINDOWS )
triplet.AppendTail("pc-windows-gnu");
if ( kernel == TARGET_KERNEL_UNKNOWN )
triplet.AppendTail("unknown-unknown");
if ( kernel == TARGET_KERNEL_LINUX )
triplet.AppendTail("unknown-linux-gnu");
if ( kernel == TARGET_KERNEL_WINDOWS )
triplet.AppendTail("pc-windows-gnu");
if ( kernel == TARGET_KERNEL_DARWIN )
triplet.AppendTail("apple-darwin");
if ( kernel == TARGET_KERNEL_IOS )
triplet.AppendTail("apple-ios");
if ( kernel == TARGET_KERNEL_ANDROID )
triplet.AppendTail("linux-android");
if ( kernel == TARGET_KERNEL_WASI )
triplet.AppendTail("unknown-wasi");
if ( kernel == TARGET_KERNEL_EMSCRIPTEN )
triplet.AppendTail("unknown-emscripten");
return triplet;
@@ -40,11 +52,15 @@ Target_t Target_t::HostTarget()
.optimization = TARGET_DEBUG,
};
};
//-----------------------------------------------------------------------------
// Returns default target for build
//-----------------------------------------------------------------------------
Target_t Target_t::DefaultTarget()
{
CUtlString szDevice = ICommandLine::ParamValue("-device");
CUtlString szOS = ICommandLine::ParamValue("-os");
CUtlString szArch = ICommandLine::ParamValue("-arch");
CUtlString szDevice = CommandLine()->ParamValue("-device");
CUtlString szOS = CommandLine()->ParamValue("-os");
CUtlString szArch = CommandLine()->ParamValue("-arch");
ETargetKernel kernel =
#if defined(__linux__)
@@ -58,8 +74,12 @@ Target_t Target_t::DefaultTarget()
cpu = TARGET_CPU_AMD64;
else if ( szArch == "aarch64" )
cpu = TARGET_CPU_AARCH64;
else if ( szArch == "wasm32" )
cpu = TARGET_CPU_WASM32;
if ( szOS == "windows" )
if ( szOS == "unknown" )
kernel = TARGET_KERNEL_UNKNOWN;
else if ( szOS == "windows" )
kernel = TARGET_KERNEL_WINDOWS;
else if ( szOS == "linux" )
kernel = TARGET_KERNEL_LINUX;
@@ -67,6 +87,8 @@ Target_t Target_t::DefaultTarget()
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());

0
fpc/library/windows/windres.cpp Normal file
View File