Added generic comptime functions

They aren't usable yet.

I also switched COPYING and LICENSE so COPYING has copyright while
license has the GPL full text.

Author: makuto

COPYING

@@ -19,3 +19,6 @@
       (printf "error: failed to hot-reload\n")
       (return 1)))
   (return 0))
+
+(defun-comptime build-text-adventure ()
+  (printf "Hello, comptime!\n"))

LICENSE

@@ -39,12 +39,29 @@ MacroFunc findMacro(EvaluatorEnvironment& environment, const char* functionName)
 	return nullptr;
 }
 
+void* findCompileTimeFunction(EvaluatorEnvironment& environment, const char* functionName)
+{
+	CompileTimeFunctionTableIterator findIt =
+	    environment.compileTimeFunctions.find(std::string(functionName));
+	if (findIt != environment.compileTimeFunctions.end())
+		return findIt->second;
+	return nullptr;
+}
+
 bool isCompileTimeCodeLoaded(EvaluatorEnvironment& environment, const ObjectDefinition& definition)
 {
-	if (definition.type == ObjectType_CompileTimeMacro)
-		return findMacro(environment, definition.name->contents.c_str()) != nullptr;
-	else
-		return findGenerator(environment, definition.name->contents.c_str()) != nullptr;
+	switch (definition.type)
+	{
+		case ObjectType_CompileTimeMacro:
+			return findMacro(environment, definition.name->contents.c_str()) != nullptr;
+		case ObjectType_CompileTimeGenerator:
+			return findGenerator(environment, definition.name->contents.c_str()) != nullptr;
+		case ObjectType_CompileTimeFunction:
+			return findCompileTimeFunction(environment, definition.name->contents.c_str()) !=
+			       nullptr;
+		default:
+			return false;
+	}
 }
 
 bool addObjectDefinition(EvaluatorEnvironment& environment, ObjectDefinition& definition)
@@ -159,7 +176,8 @@ int getNextFreeBuildId(EvaluatorEnvironment& environment)
 
 bool isCompileTimeObject(ObjectType type)
 {
-	return type == ObjectType_CompileTimeMacro || type == ObjectType_CompileTimeGenerator;
+	return type == ObjectType_CompileTimeMacro || type == ObjectType_CompileTimeGenerator ||
+	       type == ObjectType_CompileTimeFunction;
 }
 
 //
@@ -527,6 +545,13 @@ int BuildExecuteCompileTimeFunctions(EvaluatorEnvironment& environment,
 		if (log.buildProcess)
 			printf("Build %s\n", definition->name->contents.c_str());
 
+		if (!definition->output)
+		{
+			ErrorAtToken(*buildObject.definition->name,
+			             "missing compile-time output. Internal code error?");
+			continue;
+		}
+
 		char convertedNameBuffer[MAX_NAME_LENGTH] = {0};
 		lispNameStyleToCNameStyle(NameStyleMode_Underscores, definition->name->contents.c_str(),
 		                          convertedNameBuffer, sizeof(convertedNameBuffer),
@@ -545,16 +570,28 @@ int BuildExecuteCompileTimeFunctions(EvaluatorEnvironment& environment,
 		NameStyleSettings nameSettings;
 		WriterFormatSettings formatSettings;
 		WriterOutputSettings outputSettings = {};
-		if (definition->type == ObjectType_CompileTimeGenerator)
-		{
-			outputSettings.sourceHeading = generatorSourceHeading;
-			outputSettings.sourceFooter = generatorSourceFooter;
-		}
-		else
+
+		switch (definition->type)
 		{
-			outputSettings.sourceHeading = macroSourceHeading;
-			outputSettings.sourceFooter = macroSourceFooter;
+			case ObjectType_CompileTimeMacro:
+				outputSettings.sourceHeading = macroSourceHeading;
+				outputSettings.sourceFooter = macroSourceFooter;
+				break;
+			case ObjectType_CompileTimeGenerator:
+				outputSettings.sourceHeading = generatorSourceHeading;
+				outputSettings.sourceFooter = generatorSourceFooter;
+				break;
+			case ObjectType_CompileTimeFunction:
+				// TODO Right now this is the same as generators, but I don't know what I really
+				// want yet. Should each compile-time function have the ability to specify this,
+				// e.g. &with-build-tools or something? Figure it out automatically?
+				outputSettings.sourceHeading = generatorSourceHeading;
+				outputSettings.sourceFooter = generatorSourceFooter;
+				break;
+			default:
+				break;
 		}
+
 		outputSettings.sourceCakelispFilename = fileOutputName;
 		{
 			char writerSourceOutputName[MAX_PATH_LENGTH] = {0};
@@ -733,15 +770,25 @@ int BuildExecuteCompileTimeFunctions(EvaluatorEnvironment& environment,
 		}
 
 		// Add to environment
-		if (buildObject.definition->type == ObjectType_CompileTimeMacro)
-		{
-			environment.macros[buildObject.definition->name->contents] =
-			    (MacroFunc)compileTimeFunction;
-		}
-		else if (buildObject.definition->type == ObjectType_CompileTimeGenerator)
+		switch (buildObject.definition->type)
 		{
-			environment.generators[buildObject.definition->name->contents] =
-			    (GeneratorFunc)compileTimeFunction;
+			case ObjectType_CompileTimeMacro:
+				environment.macros[buildObject.definition->name->contents] =
+				    (MacroFunc)compileTimeFunction;
+				break;
+			case ObjectType_CompileTimeGenerator:
+				environment.generators[buildObject.definition->name->contents] =
+				    (GeneratorFunc)compileTimeFunction;
+				break;
+			case ObjectType_CompileTimeFunction:
+				environment.compileTimeFunctions[buildObject.definition->name->contents] =
+				    (void*)compileTimeFunction;
+				break;
+			default:
+				ErrorAtToken(
+				    *buildObject.definition->name,
+				    "Tried to build definition which is not compile-time object. Code error?");
+				break;
 		}
 
 		buildObject.stage = BuildStage_ResolvingReferences;
@@ -985,9 +1032,9 @@ bool EvaluateResolveReferences(EvaluatorEnvironment& environment)
 		}
 	}
 
-	// Keep propagating and evaluating until no more references are resolved.
-	// This must be done in passes in case evaluation created more definitions. There's probably a
-	// smarter way, but I'll do it in this brute-force style first
+	// Keep propagating and evaluating until no more references are resolved. This must be done in
+	// passes in case evaluation created more definitions. There's probably a smarter way, but I'll
+	// do it in this brute-force style first
 	int numReferencesResolved = 0;
 	int numBuildResolveErrors = 0;
 	do
@@ -1127,6 +1174,8 @@ const char* objectTypeToString(ObjectType type)
 			return "Macro";
 		case ObjectType_CompileTimeGenerator:
 			return "Generator";
+		case ObjectType_CompileTimeFunction:
+			return "Compile-time Function";
 		default:
 			return "Unknown";
 	}

runtime/TestMain.cake

@@ -170,15 +170,19 @@ typedef std::pair<const std::string, ObjectDefinition> ObjectDefinitionPair;
 typedef std::unordered_map<std::string, ObjectReferencePool> ObjectReferencePoolMap;
 typedef std::pair<const std::string, ObjectReferencePool> ObjectReferencePoolPair;
 
+typedef std::unordered_map<std::string, void*> CompileTimeFunctionTable;
+typedef CompileTimeFunctionTable::iterator CompileTimeFunctionTableIterator;
+
 // Unlike context, which can't be changed, environment can be changed.
-// Use care when modifying the environment. Only add things once you know things have succeeded.
 // Keep in mind that calling functions which can change the environment may invalidate your pointers
 // if things resize.
 struct EvaluatorEnvironment
 {
 	// Compile-time-executable functions
 	MacroTable macros;
 	GeneratorTable generators;
+	// Dumping ground for functions without fixed signatures
+	CompileTimeFunctionTable compileTimeFunctions;
 
 	// We need to keep the tokens macros create around so they can be referenced by StringOperations
 	// Token vectors must not be changed after they are created or pointers to Tokens will become

src/Evaluator.cpp

@@ -59,8 +59,10 @@ enum EvaluatorScope
 enum ObjectType
 {
 	ObjectType_Function,
+
 	ObjectType_CompileTimeMacro,
 	ObjectType_CompileTimeGenerator,
+	ObjectType_CompileTimeFunction,
 };
 
 enum ObjectReferenceGuessState

src/Evaluator.hpp

@@ -429,7 +429,8 @@ bool AddDependencyGenerator(EvaluatorEnvironment& environment, const EvaluatorCo
 }
 
 bool DefunGenerator(EvaluatorEnvironment& environment, const EvaluatorContext& context,
-                    const std::vector<Token>& tokens, int startTokenIndex, GeneratorOutput& output)
+                    const std::vector<Token>& tokens, int startTokenIndex,
+                    GeneratorOutput& runtimeOutput)
 {
 	if (!ExpectEvaluatorScope("defun", tokens[startTokenIndex], context, EvaluatorScope_Module))
 		return false;
@@ -452,6 +453,26 @@ bool DefunGenerator(EvaluatorEnvironment& environment, const EvaluatorContext& c
 		return false;
 
 	bool isModuleLocal = tokens[startTokenIndex + 1].contents.compare("defun-local") == 0;
+	bool isCompileTime = tokens[startTokenIndex + 1].contents.compare("defun-comptime") == 0;
+	GeneratorOutput* functionOutput = isCompileTime ? new GeneratorOutput : &runtimeOutput;
+
+	// Register definition before evaluating body, otherwise references in body will be orphaned
+	{
+		ObjectDefinition newFunctionDef = {};
+		newFunctionDef.name = &nameToken;
+		newFunctionDef.type = isCompileTime ? ObjectType_CompileTimeFunction : ObjectType_Function;
+		// Compile-time objects only get built with compile-time references
+		newFunctionDef.isRequired = isCompileTime ? false : context.isRequired;
+		if (isCompileTime)
+			newFunctionDef.output = functionOutput;
+		if (!addObjectDefinition(environment, newFunctionDef))
+		{
+			if (isCompileTime)
+				delete functionOutput;
+			return false;
+		}
+		// Past this point, compile-time output will be handled by environment destruction
+	}
 
 	int returnTypeStart = -1;
 	std::vector<FunctionArgumentTokens> arguments;
@@ -460,30 +481,32 @@ bool DefunGenerator(EvaluatorEnvironment& environment, const EvaluatorContext& c
 
 	if (environment.enableHotReloading)
 	{
-		addStringOutput(isModuleLocal ? output.source : output.header, "extern \"C\"",
-		                StringOutMod_SpaceAfter, &tokens[startTokenIndex]);
+		addStringOutput(isModuleLocal ? functionOutput->source : functionOutput->header,
+		                "extern \"C\"", StringOutMod_SpaceAfter, &tokens[startTokenIndex]);
 	}
 
 	// TODO: Hot-reloading functions shouldn't be declared static, right?
 	if (isModuleLocal)
-		addStringOutput(output.source, "static", StringOutMod_SpaceAfter, &tokens[startTokenIndex]);
+		addStringOutput(functionOutput->source, "static", StringOutMod_SpaceAfter,
+		                &tokens[startTokenIndex]);
 
 	int endArgsIndex = FindCloseParenTokenIndex(tokens, argsIndex);
-	if (!outputFunctionReturnType(tokens, output, returnTypeStart, startTokenIndex, endArgsIndex,
+	if (!outputFunctionReturnType(tokens, *functionOutput, returnTypeStart, startTokenIndex,
+	                              endArgsIndex,
 	                              /*outputSource=*/true, /*outputHeader=*/!isModuleLocal))
 		return false;
 
-	addStringOutput(output.source, nameToken.contents, StringOutMod_ConvertFunctionName,
+	addStringOutput(functionOutput->source, nameToken.contents, StringOutMod_ConvertFunctionName,
 	                &nameToken);
 	if (!isModuleLocal)
-		addStringOutput(output.header, nameToken.contents, StringOutMod_ConvertFunctionName,
-		                &nameToken);
+		addStringOutput(functionOutput->header, nameToken.contents,
+		                StringOutMod_ConvertFunctionName, &nameToken);
 
-	addLangTokenOutput(output.source, StringOutMod_OpenParen, &argsStart);
+	addLangTokenOutput(functionOutput->source, StringOutMod_OpenParen, &argsStart);
 	if (!isModuleLocal)
-		addLangTokenOutput(output.header, StringOutMod_OpenParen, &argsStart);
+		addLangTokenOutput(functionOutput->header, StringOutMod_OpenParen, &argsStart);
 
-	if (!outputFunctionArguments(tokens, output, arguments, /*outputSource=*/true,
+	if (!outputFunctionArguments(tokens, *functionOutput, arguments, /*outputSource=*/true,
 	                             /*outputHeader=*/!isModuleLocal))
 		return false;
 
@@ -498,41 +521,35 @@ bool DefunGenerator(EvaluatorEnvironment& environment, const EvaluatorContext& c
 		argumentsMetadata.push_back({tokens[arg.nameIndex].contents, startTypeToken, endTypeToken});
 	}
 
-	addLangTokenOutput(output.source, StringOutMod_CloseParen, &tokens[endArgsIndex]);
+	addLangTokenOutput(functionOutput->source, StringOutMod_CloseParen, &tokens[endArgsIndex]);
 	if (!isModuleLocal)
 	{
-		addLangTokenOutput(output.header, StringOutMod_CloseParen, &tokens[endArgsIndex]);
+		addLangTokenOutput(functionOutput->header, StringOutMod_CloseParen, &tokens[endArgsIndex]);
 		// Forward declarations end with ;
-		addLangTokenOutput(output.header, StringOutMod_EndStatement, &tokens[endArgsIndex]);
-	}
-
-	// Register definition before evaluating body, otherwise references in body will be orphaned
-	{
-		ObjectDefinition newFunctionDef = {};
-		newFunctionDef.name = &nameToken;
-		newFunctionDef.type = ObjectType_Function;
-		newFunctionDef.isRequired = context.isRequired;
-		if (!addObjectDefinition(environment, newFunctionDef))
-			return false;
+		addLangTokenOutput(functionOutput->header, StringOutMod_EndStatement,
+		                   &tokens[endArgsIndex]);
 	}
 
 	int startBodyIndex = endArgsIndex + 1;
-	addLangTokenOutput(output.source, StringOutMod_OpenBlock, &tokens[startBodyIndex]);
+	addLangTokenOutput(functionOutput->source, StringOutMod_OpenBlock, &tokens[startBodyIndex]);
 
 	// Evaluate our body!
 	EvaluatorContext bodyContext = context;
 	bodyContext.scope = EvaluatorScope_Body;
 	bodyContext.definitionName = &nameToken;
 	// The statements will need to handle their ;
 	int numErrors = EvaluateGenerateAll_Recursive(environment, bodyContext, tokens, startBodyIndex,
-	                                              /*delimiterTemplate=*/nullptr, output);
+	                                              /*delimiterTemplate=*/nullptr, *functionOutput);
 	if (numErrors)
+	{
+		// Don't delete compile time function output. Evaluate may have caused references to it
 		return false;
+	}
 
-	addLangTokenOutput(output.source, StringOutMod_CloseBlock, &tokens[endTokenIndex]);
+	addLangTokenOutput(functionOutput->source, StringOutMod_CloseBlock, &tokens[endTokenIndex]);
 
-	output.functions.push_back({nameToken.contents, &tokens[startTokenIndex],
-	                            &tokens[endTokenIndex], std::move(argumentsMetadata)});
+	functionOutput->functions.push_back({nameToken.contents, &tokens[startTokenIndex],
+	                                     &tokens[endTokenIndex], std::move(argumentsMetadata)});
 
 	return true;
 }
@@ -1969,6 +1986,7 @@ void importFundamentalGenerators(EvaluatorEnvironment& environment)
 
 	environment.generators["defun"] = DefunGenerator;
 	environment.generators["defun-local"] = DefunGenerator;
+	environment.generators["defun-comptime"] = DefunGenerator;
 
 	environment.generators["def-function-signature"] = DefFunctionSignatureGenerator;
 	environment.generators["def-function-signature-local"] = DefFunctionSignatureGenerator;