Browse Source

Precompiled headers working for comptime

Windows is untested, and I haven't cleaned up the code yet.
precompiled-headers
Macoy Madson 4 months ago
parent
commit
9e76f77631
13 changed files with 207 additions and 55 deletions
  1. +29
    -20
      src/Build.cpp
  2. +6
    -0
      src/Build.hpp
  3. +89
    -28
      src/Evaluator.cpp
  4. +7
    -0
      src/Evaluator.hpp
  5. +6
    -0
      src/Generators.cpp
  6. +35
    -3
      src/ModuleManager.cpp
  7. +13
    -2
      src/OutputPreambles.cpp
  8. +2
    -0
      src/OutputPreambles.hpp
  9. +13
    -0
      src/RunProcess.cpp
  10. +1
    -0
      src/RunProcessEnums.hpp
  11. +3
    -1
      src/Writer.cpp
  12. +2
    -0
      src/Writer.hpp
  13. +1
    -1
      test/RunTests.cake

+ 29
- 20
src/Build.cpp View File

@ -24,6 +24,7 @@ const char* compilerImportLibraryExtension = "lib";
const char* linkerDynamicLibraryPrefix = ""; // Not applicable
const char* linkerDynamicLibraryExtension = "dll";
const char* defaultExecutableName = "output.exe";
const char* precompiledHeaderExtension = "pch";
#else
const char* compilerObjectExtension = "o";
const char* compilerDebugSymbolsExtension = ""; // Not applicable
@ -31,10 +32,9 @@ const char* compilerImportLibraryExtension = ""; // Not applicable
const char* linkerDynamicLibraryPrefix = "lib";
const char* linkerDynamicLibraryExtension = "so";
const char* defaultExecutableName = "a.out";
const char* precompiledHeaderExtension = "gch";
#endif
const char* precompiledHeaderExtension = "pch";
void makeIncludeArgument(char* buffer, int bufferSize, const char* searchDir)
{
// TODO: Make this a setting rather than a define
@ -119,24 +119,6 @@ void makeExecutableOutputArgument(char* buffer, int bufferSize, const char* exec
}
}
void makePrecompiledHeaderOutputArgument(char* buffer, int bufferSize, const char* executableName,
const char* linkExecutable)
{
// Annoying exception for MSVC not having spaces between some arguments
if (StrCompareIgnoreCase(linkExecutable, "cl.exe") == 0)
{
SafeSnprintf(buffer, bufferSize, "/Fe\"%s\"", executableName);
}
else if (StrCompareIgnoreCase(linkExecutable, "link.exe") == 0)
{
SafeSnprintf(buffer, bufferSize, "/out:\"%s\"", executableName);
}
else
{
SafeSnprintf(buffer, bufferSize, "%s", executableName);
}
}
void makeLinkLibraryArgument(char* buffer, int bufferSize, const char* libraryName,
const char* linkExecutable)
{
@ -208,6 +190,33 @@ void makeLinkerArgument(char* buffer, int bufferSize, const char* argument,
}
}
void makePrecompiledHeaderOutputArgument(char* buffer, int bufferSize, const char* outputName,
const char* precompilerExecutable)
{
if (StrCompareIgnoreCase(precompilerExecutable, "cl.exe") == 0)
{
SafeSnprintf(buffer, bufferSize, "/Yc%s", outputName);
}
else
{
SafeSnprintf(buffer, bufferSize, "%s", outputName);
}
}
void makePrecompiledHeaderIncludeArgument(char* buffer, int bufferSize,
const char* precompiledHeaderName,
const char* buildExecutable)
{
if (StrCompareIgnoreCase(buildExecutable, "cl.exe") == 0)
{
SafeSnprintf(buffer, bufferSize, "/Yu%s", precompiledHeaderName);
}
else
{
SafeSnprintf(buffer, bufferSize, "%s", precompiledHeaderName);
}
}
void convertBuildArguments(BuildArgumentConverter* argumentsToConvert, int numArgumentsToConvert,
const char* buildExecutable)
{


+ 6
- 0
src/Build.hpp View File

@ -13,6 +13,7 @@ extern const char* compilerImportLibraryExtension;
extern const char* linkerDynamicLibraryPrefix;
extern const char* linkerDynamicLibraryExtension;
extern const char* defaultExecutableName;
extern const char* precompiledHeaderExtension;
struct BuildArgumentConverter
{
@ -47,6 +48,11 @@ void makeLinkLibraryRuntimeSearchDirArgument(char* buffer, int bufferSize, const
const char* linkExecutable);
void makeLinkerArgument(char* buffer, int bufferSize, const char* argument,
const char* linkExecutable);
void makePrecompiledHeaderOutputArgument(char* buffer, int bufferSize, const char* outputName,
const char* precompilerExecutable);
void makePrecompiledHeaderIncludeArgument(char* buffer, int bufferSize,
const char* precompiledHeaderName,
const char* buildExecutable);
// On Windows, extra work is done to find the compiler and linker executables. This function handles
// looking up those environment variables to determine which executable to use


+ 89
- 28
src/Evaluator.cpp View File

@ -861,21 +861,25 @@ bool ComptimePrepareHeaders(EvaluatorEnvironment& environment)
environment.cakelispSrcDir.empty() ? "src" : environment.cakelispSrcDir);
}
char combinedHeaderFilename[MAX_PATH_LENGTH] = {0};
PrintfBuffer(combinedHeaderFileName, "%s/%s", outputDir, combinedHeaderName);
char combinedHeaderRelativePath[MAX_PATH_LENGTH] = {0};
PrintfBuffer(combinedHeaderRelativePath, "%s/%s", outputDir, combinedHeaderName);
std::vector<const char*> headersToCombine(ArraySize(g_comptimeDefaultHeaders));
for (int i = 0; i < ArraySize(g_comptimeDefaultHeaders); ++i)
headersToCombine[i] = g_comptimeDefaultHeaders[i];
if (!writeCombinedHeader(combinedHeaderFilename, headersToCombine))
if (!writeCombinedHeader(combinedHeaderRelativePath, headersToCombine))
return false;
const char* buildExecutable =
environment.compileTimeHeaderPrecompilerCommand.fileToExecute.c_str();
char precompiledHeaderFilename[MAX_PATH_LENGTH] = {0};
if (!outputFilenameFromSourceFilename(outputDir, combinedHeaderFilename,
precompiledHeaderExtension))
if (!outputFilenameFromSourceFilename(outputDir, combinedHeaderRelativePath,
precompiledHeaderExtension, precompiledHeaderFilename,
sizeof(precompiledHeaderFilename)))
{
Logf("error: failed to prepare precompiled header output filename");
Log("error: failed to prepare precompiled header output filename");
return false;
}
@ -884,8 +888,6 @@ bool ComptimePrepareHeaders(EvaluatorEnvironment& environment)
sizeof(precompiledHeaderOutputArgument),
precompiledHeaderFilename, buildExecutable);
const char* buildExecutable = environment.comptimePrecompileHeaderBuildCommand.fileToExecute.c_str();
char headerInclude[MAX_PATH_LENGTH] = {0};
if (environment.cakelispSrcDir.empty())
makeIncludeArgument(headerInclude, sizeof(headerInclude), "src/");
@ -896,35 +898,60 @@ bool ComptimePrepareHeaders(EvaluatorEnvironment& environment)
char precompileHeaderExecutable[MAX_PATH_LENGTH] = {0};
if (!resolveExecutablePath(buildExecutable, precompileHeaderExecutable,
sizeof(precompileHeaderExecutable)))
// TODO: Add error message?
continue;
return false;
ProcessCommandInput precompileHeaderInputs[] = {
{ProcessCommandArgumentType_SourceInput, {combinedHeaderFilename}},
{ProcessCommandArgumentType_SourceInput, {combinedHeaderRelativePath}},
{ProcessCommandArgumentType_PrecompiledHeaderOutput, {precompiledHeaderOutputArgument}},
{ProcessCommandArgumentType_CakelispHeadersInclude, {headerInclude}}};
const char** buildArguments = MakeProcessArgumentsFromCommand(
precompileHeaderExecutable, environment.comptimePrecompileHeaderBuildCommand.arguments,
precompileHeaderExecutable, environment.compileTimeHeaderPrecompilerCommand.arguments,
precompileHeaderInputs, ArraySize(precompileHeaderInputs));
if (!buildArguments)
{
// TODO: Abort building if cannot invoke compiler
continue;
return false;
}
// Can we use the cached version?
if (!cppFileNeedsBuild(environment, combinedHeaderFilename, precompiledHeaderFilename,
if (!cppFileNeedsBuild(environment, combinedHeaderRelativePath, precompiledHeaderFilename,
buildArguments, environment.comptimeCachedCommandCrcs,
environment.comptimeNewCommandCrcs,
environment.comptimeHeaderModifiedCache, headerSearchDirectories))
{
if (logging.buildProcess)
Logf("Skipping precompiling %s (using cached header)\n", sourceOutputName);
Logf("No need to update precompiled header %s\n", precompiledHeaderFilename);
environment.comptimeHeadersPrepared = true;
environment.comptimeCombinedHeaderFilename = combinedHeaderName;
return true;
}
environment.comptimeHeadersPrepared = true;
return true;
if (logging.buildProcess)
Logf("Updating precompiled header %s\n", precompiledHeaderFilename);
RunProcessArguments arguments = {};
arguments.fileToExecute = buildExecutable;
arguments.arguments = buildArguments;
int status = -1;
if (runProcess(arguments, &status) != 0)
{
free(buildArguments);
return false;
}
free(buildArguments);
waitForAllProcessesClosed(OnCompileProcessOutput);
if (status == 0)
{
environment.comptimeHeadersPrepared = true;
environment.comptimeCombinedHeaderFilename = combinedHeaderName;
return true;
}
Logf("Failed to update precompiled header %s\n", precompiledHeaderFilename);
return false;
}
int BuildExecuteCompileTimeFunctions(EvaluatorEnvironment& environment,
@ -942,6 +969,44 @@ int BuildExecuteCompileTimeFunctions(EvaluatorEnvironment& environment,
}
}
char compileTimeBuildExecutable[MAX_PATH_LENGTH] = {0};
if (!resolveExecutablePath(environment.compileTimeBuildCommand.fileToExecute.c_str(),
compileTimeBuildExecutable, sizeof(compileTimeBuildExecutable)))
{
Logf("error: could not find compile-time compiler %s\n",
environment.compileTimeBuildCommand.fileToExecute.c_str());
++numErrorsOut;
return 0;
}
bool comptimeCanUsePrecompiledHeaders = environment.comptimeUsePrecompiledHeaders &&
environment.comptimeHeadersPrepared &&
!environment.comptimeCombinedHeaderFilename.empty();
const char* cakelispCombinedHeaderFilename = nullptr;
char usePrecompiledHeaderArgument[MAX_PATH_LENGTH] = {0};
std::vector<std::string> precompiledHeadersToIncludeStorage;
std::vector<const char*> precompiledHeadersToInclude;
if (comptimeCanUsePrecompiledHeaders)
{
cakelispCombinedHeaderFilename = environment.comptimeCombinedHeaderFilename.c_str();
makePrecompiledHeaderIncludeArgument(
usePrecompiledHeaderArgument, sizeof(usePrecompiledHeaderArgument),
cakelispCombinedHeaderFilename, compileTimeBuildExecutable);
// TODO: Hard-coded compiler option bad
precompiledHeadersToIncludeStorage.push_back("-include");
precompiledHeadersToIncludeStorage.push_back(cakelispCombinedHeaderFilename);
precompiledHeadersToInclude.reserve(precompiledHeadersToIncludeStorage.size());
for (const std::string& arg : precompiledHeadersToIncludeStorage)
precompiledHeadersToInclude.push_back(arg.c_str());
}
// TODO: Don't hard-code cakelispWorkingDir
char precompiledHeadersInclude[MAX_PATH_LENGTH] = {0};
makeIncludeArgument(precompiledHeadersInclude, sizeof(precompiledHeadersInclude),
"cakelisp_cache/");
// Spin up as many compile processes as necessary
// TODO: Combine sure-thing builds into batches (ones where we know all references)
// TODO: Make pipeline able to start e.g. linker while other objects are still compiling
@ -984,7 +1049,8 @@ int BuildExecuteCompileTimeFunctions(EvaluatorEnvironment& environment,
GeneratorOutput header;
GeneratorOutput footer;
GeneratorOutput autoIncludes;
makeCompileTimeHeaderFooter(header, footer, &autoIncludes,
makeCompileTimeHeaderFooter(header, footer, cakelispCombinedHeaderFilename, &autoIncludes,
definition->definitionInvocation);
outputSettings.heading = &header;
outputSettings.footer = &footer;
@ -1112,18 +1178,13 @@ int BuildExecuteCompileTimeFunctions(EvaluatorEnvironment& environment,
makeDebugSymbolsOutputArgument(debugSymbolsArgument, sizeof(debugSymbolsArgument),
debugSymbolsName);
char compileTimeBuildExecutable[MAX_PATH_LENGTH] = {0};
if (!resolveExecutablePath(environment.compileTimeBuildCommand.fileToExecute.c_str(),
compileTimeBuildExecutable, sizeof(compileTimeBuildExecutable)))
// TODO: Add error message?
continue;
ProcessCommandInput compileTimeInputs[] = {
{ProcessCommandArgumentType_SourceInput, {sourceOutputName}},
{ProcessCommandArgumentType_ObjectOutput, {buildObjectArgument}},
{ProcessCommandArgumentType_DebugSymbolsOutput, {debugSymbolsArgument}},
{ProcessCommandArgumentType_CakelispHeadersInclude, {headerInclude}}};
{ProcessCommandArgumentType_DebugSymbolsOutput, {debugSymbolsArgument}},
{ProcessCommandArgumentType_CakelispHeadersInclude,
{headerInclude, precompiledHeadersInclude}},
{ProcessCommandArgumentType_PrecompiledHeaderInclude, precompiledHeadersToInclude}};
const char** buildArguments = MakeProcessArgumentsFromCommand(
compileTimeBuildExecutable, environment.compileTimeBuildCommand.arguments,
compileTimeInputs, ArraySize(compileTimeInputs));


+ 7
- 0
src/Evaluator.hpp View File

@ -330,6 +330,12 @@ struct EvaluatorEnvironment
// the source file hasn't been modified more recently)
bool useCachedFiles;
// Save a huge amount of time by precompiling Cakelisp headers
bool comptimeUsePrecompiledHeaders;
bool comptimeHeadersPrepared;
// Note that this is the header without the precompilation extension
std::string comptimeCombinedHeaderFilename;
// Added as a search directory for compile time code execution
std::string cakelispSrcDir;
@ -359,6 +365,7 @@ struct EvaluatorEnvironment
ProcessCommand compileTimeLinkCommand;
ProcessCommand buildTimeBuildCommand;
ProcessCommand buildTimeLinkCommand;
ProcessCommand compileTimeHeaderPrecompilerCommand;
// At this point, all known references are resolved. This is the best time to let the user do
// arbitrary code generation and modification. These changes will need to be evaluated and their


+ 6
- 0
src/Generators.cpp View File

@ -72,6 +72,8 @@ bool SetProcessCommandArguments(EvaluatorEnvironment& environment, const std::ve
{"'include-search-dirs", ProcessCommandArgumentType_IncludeSearchDirs},
{"'additional-options", ProcessCommandArgumentType_AdditionalOptions},
{"'precompiled-header-output", ProcessCommandArgumentType_PrecompiledHeaderOutput},
{"'precompiled-header-include",
ProcessCommandArgumentType_PrecompiledHeaderInclude},
{"'object-input", ProcessCommandArgumentType_ObjectInput},
{"'library-output", ProcessCommandArgumentType_DynamicLibraryOutput},
{"'executable-output", ProcessCommandArgumentType_ExecutableOutput},
@ -209,6 +211,10 @@ bool SetCakelispOption(EvaluatorEnvironment& environment, const EvaluatorContext
{"compile-time-linker", &environment.compileTimeLinkCommand, SetProcessCommandFileToExec},
{"compile-time-link-arguments", &environment.compileTimeLinkCommand,
SetProcessCommandArguments},
{"compile-time-header-precompiler", &environment.compileTimeHeaderPrecompilerCommand,
SetProcessCommandFileToExec},
{"compile-time-header-precompiler-arguments",
&environment.compileTimeHeaderPrecompilerCommand, SetProcessCommandArguments},
{"build-time-compiler", &environment.buildTimeBuildCommand, SetProcessCommandFileToExec},
{"build-time-compile-arguments", &environment.buildTimeBuildCommand,
SetProcessCommandArguments},


+ 35
- 3
src/ModuleManager.cpp View File

@ -116,6 +116,21 @@ void moduleManagerInitialize(ModuleManager& manager)
{ProcessCommandArgumentType_DynamicLibraryOutput, EmptyString},
{ProcessCommandArgumentType_ObjectInput, EmptyString}};
// TODO Precompiled headers on windows. See
// https://docs.microsoft.com/en-us/cpp/build/creating-precompiled-header-files?view=msvc-160
// https://docs.microsoft.com/en-us/cpp/build/reference/yc-create-precompiled-header-file?view=msvc-160
// https://docs.microsoft.com/en-us/cpp/build/reference/yu-use-precompiled-header-file?view=msvc-160
manager.environment.compileTimeHeaderPrecompilerCommand.fileToExecute = "cl.exe";
manager.environment.compileTimeHeaderPrecompilerCommand.arguments = {
{ProcessCommandArgumentType_String, "/nologo"},
{ProcessCommandArgumentType_String, "/EHsc"},
{ProcessCommandArgumentType_String, "/c"},
{ProcessCommandArgumentType_SourceInput, EmptyString},
{ProcessCommandArgumentType_ObjectOutput, EmptyString},
{ProcessCommandArgumentType_DebugSymbolsOutput, EmptyString},
{ProcessCommandArgumentType_IncludeSearchDirs, EmptyString},
{ProcessCommandArgumentType_AdditionalOptions, EmptyString}};
manager.environment.buildTimeBuildCommand.fileToExecute = "cl.exe";
manager.environment.buildTimeBuildCommand.arguments = {
{ProcessCommandArgumentType_String, "/nologo"},
@ -138,15 +153,19 @@ void moduleManagerInitialize(ModuleManager& manager)
{ProcessCommandArgumentType_LibraryRuntimeSearchDirs, EmptyString},
{ProcessCommandArgumentType_LinkerArguments, EmptyString}};
#else
// manager.environment.comptimeUsePrecompiledHeaders = false; // 13.2 seconds Debug; 10.25 no debug
manager.environment.comptimeUsePrecompiledHeaders = true; // 7.37 seconds (including building pch, 6.21 w/o); 3.728s no debug (excluding pch; if build pch, 4.62s)
// G++ by default
manager.environment.compileTimeBuildCommand.fileToExecute = "g++";
manager.environment.compileTimeBuildCommand.arguments = {
{ProcessCommandArgumentType_String, "-g"},
{ProcessCommandArgumentType_String, "-c"},
// {ProcessCommandArgumentType_String, "-g"},
{ProcessCommandArgumentType_String, "-c"},
{ProcessCommandArgumentType_SourceInput, EmptyString},
{ProcessCommandArgumentType_String, "-o"},
{ProcessCommandArgumentType_ObjectOutput, EmptyString},
{ProcessCommandArgumentType_CakelispHeadersInclude, EmptyString},
{ProcessCommandArgumentType_CakelispHeadersInclude, EmptyString},
{ProcessCommandArgumentType_PrecompiledHeaderInclude, EmptyString},
{ProcessCommandArgumentType_String, "-fPIC"}};
manager.environment.compileTimeLinkCommand.fileToExecute = "g++";
@ -156,6 +175,19 @@ void moduleManagerInitialize(ModuleManager& manager)
{ProcessCommandArgumentType_DynamicLibraryOutput, EmptyString},
{ProcessCommandArgumentType_ObjectInput, EmptyString}};
// Note that this command must match the compilation command to be compatible, see
// https://gcc.gnu.org/onlinedocs/gcc/Precompiled-Headers.html
manager.environment.compileTimeHeaderPrecompilerCommand.fileToExecute = "g++";
manager.environment.compileTimeHeaderPrecompilerCommand.arguments = {
// {ProcessCommandArgumentType_String, "-g"},
{ProcessCommandArgumentType_String, "-x"},
{ProcessCommandArgumentType_String, "c++-header"},
{ProcessCommandArgumentType_SourceInput, EmptyString},
{ProcessCommandArgumentType_String, "-o"},
{ProcessCommandArgumentType_PrecompiledHeaderOutput, EmptyString},
{ProcessCommandArgumentType_CakelispHeadersInclude, EmptyString},
{ProcessCommandArgumentType_String, "-fPIC"}};
manager.environment.buildTimeBuildCommand.fileToExecute = "g++";
manager.environment.buildTimeBuildCommand.arguments = {
{ProcessCommandArgumentType_String, "-g"},


+ 13
- 2
src/OutputPreambles.cpp View File

@ -10,15 +10,26 @@ const char* g_comptimeDefaultHeaders[10] = {
"Build.hpp", "FileUtilities.hpp"};
void makeCompileTimeHeaderFooter(GeneratorOutput& headerOut, GeneratorOutput& footerOut,
const char* comptimeCombinedHeaderFilename,
GeneratorOutput* spliceAfterHeaders, const Token* blameToken)
{
for (unsigned int i = 0; i < ArraySize(g_comptimeDefaultHeaders); ++i)
if (comptimeCombinedHeaderFilename)
{
addStringOutput(headerOut.source, "#include", StringOutMod_SpaceAfter, blameToken);
addStringOutput(headerOut.source, g_comptimeDefaultHeaders[i],
addStringOutput(headerOut.source, comptimeCombinedHeaderFilename,
StringOutMod_SurroundWithQuotes, blameToken);
addLangTokenOutput(headerOut.source, StringOutMod_NewlineAfter, blameToken);
}
else
{
for (unsigned int i = 0; i < ArraySize(g_comptimeDefaultHeaders); ++i)
{
addStringOutput(headerOut.source, "#include", StringOutMod_SpaceAfter, blameToken);
addStringOutput(headerOut.source, g_comptimeDefaultHeaders[i],
StringOutMod_SurroundWithQuotes, blameToken);
addLangTokenOutput(headerOut.source, StringOutMod_NewlineAfter, blameToken);
}
}
addLangTokenOutput(headerOut.source, StringOutMod_NewlineAfter, blameToken);


+ 2
- 0
src/OutputPreambles.hpp View File

@ -3,7 +3,9 @@
struct GeneratorOutput;
struct Token;
// If comptimeCombinedHeaderFilename is null, g_comptimeDefaultHeaders will be inserted instead
void makeCompileTimeHeaderFooter(GeneratorOutput& headerOut, GeneratorOutput& footerOut,
const char* comptimeCombinedHeaderFilename,
GeneratorOutput* spliceAfterHeaders, const Token* blameToken);
void makeRunTimeHeaderFooter(GeneratorOutput& headerOut, GeneratorOutput& footerOut,
const Token* blameToken);


+ 13
- 0
src/RunProcess.cpp View File

@ -508,6 +508,8 @@ static const char* ProcessCommandArgumentTypeToString(ProcessCommandArgumentType
return "AdditionalOptions";
case ProcessCommandArgumentType_PrecompiledHeaderOutput:
return "PrecompiledHeaderOutput";
case ProcessCommandArgumentType_PrecompiledHeaderInclude:
return "PrecompiledHeaderInclude";
case ProcessCommandArgumentType_ObjectInput:
return "ObjectInput";
case ProcessCommandArgumentType_DynamicLibraryOutput:
@ -548,7 +550,18 @@ const char** MakeProcessArgumentsFromCommand(const char* fileToExecute,
if (inputs[input].type == argument.type)
{
for (const char* value : inputs[input].value)
{
if (!value || !value[0])
{
Logf(
"warning: attempted to pass null string to '%s' under argument "
"type %s. It will be ignored\n",
fileToExecute, ProcessCommandArgumentTypeToString(argument.type));
continue;
}
argumentsAccumulate.push_back(value);
}
found = true;
break;
}


+ 1
- 0
src/RunProcessEnums.hpp View File

@ -17,6 +17,7 @@ enum ProcessCommandArgumentType
ProcessCommandArgumentType_AdditionalOptions,
ProcessCommandArgumentType_PrecompiledHeaderOutput,
ProcessCommandArgumentType_PrecompiledHeaderInclude,
ProcessCommandArgumentType_ObjectInput,
ProcessCommandArgumentType_DynamicLibraryOutput,


+ 3
- 1
src/Writer.cpp View File

@ -502,7 +502,9 @@ bool writeCombinedHeader(const char* combinedHeaderFilename,
return false;
}
fprint(combinedHeaderFile, "#pragma once\n");
// G++ complains if there's one of these in the "main" file. When we precompile, the header is
// always the main file
// fprintf(combinedHeaderFile, "#pragma once\n");
for (const char* sourceHeader : headersToInclude)
{


+ 2
- 0
src/Writer.hpp View File

@ -1,5 +1,7 @@
#pragma once
#include <vector>
#include "ConverterEnums.hpp"
#include "EvaluatorEnums.hpp"
#include "WriterEnums.hpp"


+ 1
- 1
test/RunTests.cake View File

@ -43,7 +43,7 @@
(var test-file (* (const char)) (field (at i tests) test-file))
(Logf "\n===============\n%s\n\n" test-name)
(run-process-sequential-or
(cakelisp-executable "--execute" platform-config test-file)
(cakelisp-executable "--execute" "--verbose-build-process" platform-config test-file)
(Logf "error: test %s failed\n" test-name)
(return false))
(Logf "\n%s succeeded\n" test-name)


Loading…
Cancel
Save