255 lines
10 KiB
Python
255 lines
10 KiB
Python
"""Generate IDE files from data/compile.json (the server's per-unit compiler flags).
|
|
|
|
python scripts/exe/gen_ide.py
|
|
|
|
Needs no td. System headers come from the toolchain scripts/exe/build_exe.py would build with (--toolchain DIR,
|
|
RODECOMP_TOOLCHAIN, .td/config.json, then a Visual Studio install with MSVC v142 14.29 + Windows SDK 10.0.19041);
|
|
without one the files are still written, only IntelliSense lacks the system headers until it is installed.
|
|
|
|
Writes, all under build/ (git-ignored, regenerate after `td sync` or a data/compile.json change):
|
|
|
|
build/Ragexe.sln, build/Ragexe.vcxproj (+ .filters)
|
|
A Visual Studio "Makefile" project. Build runs scripts/exe/build_exe.py, Rebuild
|
|
runs it after deleting build/exe, Clean deletes build/exe, and Debug starts build/exe/Ragexe.exe. Every
|
|
unit appears in Solution Explorer under its folder; IntelliSense gets the defines and include paths of
|
|
each unit's flag set.
|
|
build/editor-x86/compile_commands.json
|
|
One entry per unit with its exact cl.exe command, for clangd (.clangd points here), VS Code and CLion.
|
|
|
|
The build itself stays build_exe.py; these files only call it.
|
|
"""
|
|
|
|
import argparse
|
|
import json
|
|
import os
|
|
import re
|
|
import sys
|
|
import uuid
|
|
from pathlib import Path
|
|
from xml.sax.saxutils import escape
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
import build_exe # noqa: E402
|
|
|
|
ROOT = build_exe.ROOT
|
|
BUILD = ROOT / "build"
|
|
NAME = "Ragexe"
|
|
NS = uuid.UUID("6f4c1f1e-2b8a-4f0e-9a43-6c8d5b7a1e20")
|
|
|
|
|
|
def guid(text):
|
|
return "{" + str(uuid.uuid5(NS, text)).upper() + "}"
|
|
|
|
|
|
def find_toolchain(explicit):
|
|
try:
|
|
return build_exe.find_toolchain(explicit, link=False)
|
|
except build_exe.ToolchainNotFound as error:
|
|
print(f"warning: {error}\nIntelliSense will lack the system headers; rerun this script once a toolchain is installed.",
|
|
file=sys.stderr)
|
|
return None
|
|
|
|
|
|
def expand(value, tc):
|
|
if tc is not None:
|
|
return tc.expand(value, native_paths=True)
|
|
return value.replace("${SRC}", str(ROOT).replace("\\", "/"))
|
|
|
|
|
|
def system_includes(config, tc):
|
|
if tc is None:
|
|
return []
|
|
return [p for p in expand(config["env"]["INCLUDE"], tc).split(";") if p]
|
|
|
|
|
|
def compiler(config, tc):
|
|
return expand(config["compiler"], tc) if tc is not None else "cl.exe"
|
|
|
|
|
|
def defines_and_includes(flags):
|
|
defines, includes = [], []
|
|
for flag in flags:
|
|
m = re.match(r"^[-/]D(.+)$", flag)
|
|
if m:
|
|
defines.append(m.group(1))
|
|
continue
|
|
m = re.match(r"^[-/]I(.+)$", flag)
|
|
if m:
|
|
includes.append(m.group(1))
|
|
return defines, includes
|
|
|
|
|
|
def compile_commands(config, units, tc):
|
|
cl = compiler(config, tc)
|
|
# cl.exe reads the system headers from %INCLUDE%; tools reading this database don't, so pass them explicitly
|
|
system = [f"/imsvc{p}" for p in system_includes(config, tc)]
|
|
entries = []
|
|
for unit, (shape, extra) in sorted(units.items()):
|
|
args = [cl, *(expand(a, tc) for a in config["shapes"][shape]), *system]
|
|
args += [f"/I{(ROOT / d).as_posix()}" for d in extra]
|
|
prelude = build_exe.unit_prelude(unit)
|
|
if prelude:
|
|
args.append(f"/FI{prelude.as_posix()}")
|
|
args.append((ROOT / unit).as_posix())
|
|
entries.append({"directory": ROOT.as_posix(), "file": (ROOT / unit).as_posix(), "arguments": args})
|
|
out = BUILD / "editor-x86"
|
|
out.mkdir(parents=True, exist_ok=True)
|
|
(out / "compile_commands.json").write_text(json.dumps(entries, indent=1), encoding="utf-8")
|
|
return out / "compile_commands.json"
|
|
|
|
|
|
def rel(path):
|
|
return os.path.relpath(ROOT / path, BUILD).replace("/", "\\")
|
|
|
|
|
|
def vcxproj(config, units, tc):
|
|
system = escape(";".join(system_includes(config, tc)))
|
|
python = sys.executable
|
|
script = rel("scripts/exe/build_exe.py")
|
|
exe_dir = "$(SolutionDir)exe"
|
|
toolchain = f' --toolchain "{tc.vc.parent}"' if tc is not None and tc.origin.startswith("--toolchain") else ""
|
|
build_cmd = f'"{python}" "$(SolutionDir){script}" --out "{exe_dir}"{toolchain}'
|
|
clean_cmd = f'if exist "{exe_dir}" rmdir /s /q "{exe_dir}"'
|
|
|
|
# IntelliSense: per-unit defines/includes, grouped by flag set
|
|
shapes = {}
|
|
for unit, (shape, extra) in units.items():
|
|
defines, includes = defines_and_includes(expand(a, tc) for a in config["shapes"][shape])
|
|
includes += [str(ROOT / d) for d in extra]
|
|
shapes.setdefault(shape, (defines, includes))
|
|
all_defines = sorted({d for defines, _ in shapes.values() for d in defines})
|
|
all_includes = sorted({i.replace("/", "\\") for _, includes in shapes.values() for i in includes})
|
|
|
|
items = []
|
|
for unit, (shape, extra) in sorted(units.items()):
|
|
defines, includes = defines_and_includes(expand(a, tc) for a in config["shapes"][shape])
|
|
includes = [i.replace("/", "\\") for i in includes] + [str(ROOT / d) for d in extra]
|
|
items.append(
|
|
f' <ClCompile Include="{escape(rel(unit))}">\n'
|
|
f' <PreprocessorDefinitions>{escape(";".join(defines))}</PreprocessorDefinitions>\n'
|
|
f' <AdditionalIncludeDirectories>{escape(";".join(includes))}</AdditionalIncludeDirectories>\n'
|
|
f' </ClCompile>')
|
|
headers = sorted(p.relative_to(ROOT).as_posix() for d in ("Source", "Recovered") if (ROOT / d).is_dir()
|
|
for p in (ROOT / d).rglob("*") if p.suffix.lower() in (".h", ".hpp", ".inl", ".inc"))
|
|
header_items = [f' <ClInclude Include="{escape(rel(h))}" />' for h in headers]
|
|
|
|
project = f"""<?xml version="1.0" encoding="utf-8"?>
|
|
<Project DefaultTargets="Build" ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
|
<ItemGroup Label="ProjectConfigurations">
|
|
<ProjectConfiguration Include="Release|Win32">
|
|
<Configuration>Release</Configuration>
|
|
<Platform>Win32</Platform>
|
|
</ProjectConfiguration>
|
|
</ItemGroup>
|
|
<PropertyGroup Label="Globals">
|
|
<VCProjectVersion>16.0</VCProjectVersion>
|
|
<ProjectGuid>{guid(NAME)}</ProjectGuid>
|
|
<Keyword>MakeFileProj</Keyword>
|
|
<RootNamespace>{NAME}</RootNamespace>
|
|
</PropertyGroup>
|
|
<Import Project="$(VCTargetsPath)\\Microsoft.Cpp.Default.props" />
|
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
|
|
<ConfigurationType>Makefile</ConfigurationType>
|
|
<UseDebugLibraries>false</UseDebugLibraries>
|
|
<PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
|
|
</PropertyGroup>
|
|
<Import Project="$(VCTargetsPath)\\Microsoft.Cpp.props" />
|
|
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
|
|
<OutDir>{exe_dir}\\</OutDir>
|
|
<IntDir>$(SolutionDir)vs\\</IntDir>
|
|
<NMakeOutput>{exe_dir}\\{NAME}.exe</NMakeOutput>
|
|
<NMakeBuildCommandLine>{escape(build_cmd)}</NMakeBuildCommandLine>
|
|
<NMakeReBuildCommandLine>{escape(clean_cmd)} && {escape(build_cmd)}</NMakeReBuildCommandLine>
|
|
<NMakeCleanCommandLine>{escape(clean_cmd)}</NMakeCleanCommandLine>
|
|
<NMakePreprocessorDefinitions>{escape(";".join(all_defines))}</NMakePreprocessorDefinitions>
|
|
<NMakeIncludeSearchPath>{escape(";".join(all_includes))}</NMakeIncludeSearchPath>
|
|
<AdditionalOptions>/std:c++20 /Zc:__cplusplus</AdditionalOptions>
|
|
<IncludePath>{system}</IncludePath>
|
|
<ExternalIncludePath>{system}</ExternalIncludePath>
|
|
<LocalDebuggerCommand>{exe_dir}\\{NAME}.exe</LocalDebuggerCommand>
|
|
<LocalDebuggerWorkingDirectory>{exe_dir}\\</LocalDebuggerWorkingDirectory>
|
|
<DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
|
|
</PropertyGroup>
|
|
<ItemGroup>
|
|
{chr(10).join(items)}
|
|
</ItemGroup>
|
|
<ItemGroup>
|
|
{chr(10).join(header_items)}
|
|
</ItemGroup>
|
|
<Import Project="$(VCTargetsPath)\\Microsoft.Cpp.targets" />
|
|
</Project>
|
|
"""
|
|
(BUILD / f"{NAME}.vcxproj").write_text(project, encoding="utf-8-sig")
|
|
|
|
# filters: mirror the folder tree
|
|
files = [*units, *headers]
|
|
folders = set()
|
|
for f in files:
|
|
parts = Path(f).parent.parts
|
|
for i in range(1, len(parts) + 1):
|
|
folders.add("\\".join(parts[:i]))
|
|
filter_defs = "\n".join(
|
|
f' <Filter Include="{escape(f)}">\n <UniqueIdentifier>{guid("filter:" + f)}</UniqueIdentifier>\n </Filter>'
|
|
for f in sorted(folders))
|
|
|
|
def filter_item(tag, f):
|
|
folder = "\\".join(Path(f).parent.parts)
|
|
return f' <{tag} Include="{escape(rel(f))}">\n <Filter>{escape(folder)}</Filter>\n </{tag}>'
|
|
filters = f"""<?xml version="1.0" encoding="utf-8"?>
|
|
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
|
|
<ItemGroup>
|
|
{filter_defs}
|
|
</ItemGroup>
|
|
<ItemGroup>
|
|
{chr(10).join(filter_item("ClCompile", u) for u in sorted(units))}
|
|
</ItemGroup>
|
|
<ItemGroup>
|
|
{chr(10).join(filter_item("ClInclude", h) for h in headers)}
|
|
</ItemGroup>
|
|
</Project>
|
|
"""
|
|
(BUILD / f"{NAME}.vcxproj.filters").write_text(filters, encoding="utf-8-sig")
|
|
|
|
project_guid = guid(NAME)
|
|
solution = f"""
|
|
Microsoft Visual Studio Solution File, Format Version 12.00
|
|
# Visual Studio Version 16
|
|
VisualStudioVersion = 16.0.28701.123
|
|
MinimumVisualStudioVersion = 10.0.40219.1
|
|
Project("{{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}}") = "{NAME}", "{NAME}.vcxproj", "{project_guid}"
|
|
EndProject
|
|
Global
|
|
\tGlobalSection(SolutionConfigurationPlatforms) = preSolution
|
|
\t\tRelease|x86 = Release|x86
|
|
\tEndGlobalSection
|
|
\tGlobalSection(ProjectConfigurationPlatforms) = postSolution
|
|
\t\t{project_guid}.Release|x86.ActiveCfg = Release|Win32
|
|
\t\t{project_guid}.Release|x86.Build.0 = Release|Win32
|
|
\tEndGlobalSection
|
|
\tGlobalSection(SolutionProperties) = preSolution
|
|
\t\tHideSolutionNode = FALSE
|
|
\tEndGlobalSection
|
|
EndGlobal
|
|
"""
|
|
(BUILD / f"{NAME}.sln").write_text(solution, encoding="utf-8-sig")
|
|
return BUILD / f"{NAME}.sln", len(units), len(headers)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
parser.add_argument("--toolchain", help="toolchain directory (td layout), passed on to build_exe.py")
|
|
args = parser.parse_args()
|
|
config = json.loads((ROOT / "data" / "compile.json").read_text(encoding="utf-8"))
|
|
units = build_exe.exe_units(config)
|
|
tc = find_toolchain(args.toolchain)
|
|
if tc is not None:
|
|
print(f"toolchain: {tc.msvc} + {tc.kits} (from {tc.origin})")
|
|
BUILD.mkdir(exist_ok=True)
|
|
db = compile_commands(config, units, tc)
|
|
sln, n_units, n_headers = vcxproj(config, units, tc)
|
|
print(f"wrote {sln} ({n_units} units, {n_headers} headers)")
|
|
print(f"wrote {db}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|