From 68106675d2dd404dd1bdb410170f3c33c78f459f Mon Sep 17 00:00:00 2001 From: Macoy Madson Date: Fri, 16 Oct 2020 09:33:54 -0700 Subject: [PATCH] Move def-type-alias into Cakelisp It now supports global vs. local --- runtime/Macros.cake | 45 ++++++++++++++++++++++--------------------- src/Generators.cpp | 47 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 22 deletions(-) diff --git a/runtime/Macros.cake b/runtime/Macros.cake index 3f86f92..36b2b70 100644 --- a/runtime/Macros.cake +++ b/runtime/Macros.cake @@ -39,32 +39,33 @@ (return true)) ;; The first significant generator written in Cakelisp! -(defgenerator def-type-alias () - (destructure-arguments name-index type-index) - (quick-token-at name-token name-index) - (quick-token-at invocation-token (+ 1 startTokenIndex)) +;; Now built-in +;; (defgenerator def-type-alias () +;; (destructure-arguments name-index type-index) +;; (quick-token-at name-token name-index) +;; (quick-token-at invocation-token (+ 1 startTokenIndex)) - ;; Make sure the type is valid before outputting anything - (var type-output (<> std::vector StringOutput)) - (var type-after-name-output (<> std::vector StringOutput)) - (unless (tokenizedCTypeToString_Recursive tokens type-index true type-output type-after-name-output) - (return false)) - (addModifierToStringOutput (on-call type-output back) StringOutMod_SpaceAfter) +;; ;; Make sure the type is valid before outputting anything +;; (var type-output (<> std::vector StringOutput)) +;; (var type-after-name-output (<> std::vector StringOutput)) +;; (unless (tokenizedCTypeToString_Recursive tokens type-index true type-output type-after-name-output) +;; (return false)) +;; (addModifierToStringOutput (on-call type-output back) StringOutMod_SpaceAfter) - (addStringOutput (field output source) "typedef" StringOutMod_SpaceAfter (addr invocation-token)) - ;; TODO: Add ability to define typedefs in header - (PushBackAll (field output source) type-output) +;; (addStringOutput (field output source) "typedef" StringOutMod_SpaceAfter (addr invocation-token)) +;; ;; TODO: Add ability to define typedefs in header +;; (PushBackAll (field output source) type-output) - ;; Evaluate name - (var expressionContext EvaluatorContext context) - (set (field expressionContext scope) EvaluatorScope_ExpressionsOnly) - (unless (= 0 (EvaluateGenerate_Recursive environment expressionContext tokens name-index output)) - (return false)) +;; ;; Evaluate name +;; (var expressionContext EvaluatorContext context) +;; (set (field expressionContext scope) EvaluatorScope_ExpressionsOnly) +;; (unless (= 0 (EvaluateGenerate_Recursive environment expressionContext tokens name-index output)) +;; (return false)) - ;; Yep, believe it or not, C typedefs have the length of the array after the new type name - (PushBackAll (field output source) type-after-name-output) - (addLangTokenOutput (field output source) StringOutMod_EndStatement (addr invocation-token)) - (return true)) +;; ;; Yep, believe it or not, C typedefs have the length of the array after the new type name +;; (PushBackAll (field output source) type-after-name-output) +;; (addLangTokenOutput (field output source) StringOutMod_EndStatement (addr invocation-token)) +;; (return true)) (defmacro array-size () (destructure-arguments array-index) diff --git a/src/Generators.cpp b/src/Generators.cpp index a14c8e1..e3084c8 100644 --- a/src/Generators.cpp +++ b/src/Generators.cpp @@ -927,6 +927,50 @@ bool ObjectPathGenerator(EvaluatorEnvironment& environment, const EvaluatorConte return true; } +static bool DefTypeAliasGenerator(EvaluatorEnvironment& environment, + const EvaluatorContext& context, const std::vector& tokens, + int startTokenIndex, GeneratorOutput& output) +{ + int destrEndInvocationIndex = FindCloseParenTokenIndex(tokens, startTokenIndex); + int nameIndex = + getExpectedArgument("name-index", tokens, startTokenIndex, 1, destrEndInvocationIndex); + if (-1 == nameIndex) + return false; + + int typeIndex = + getExpectedArgument("type-index", tokens, startTokenIndex, 2, destrEndInvocationIndex); + if (-1 == typeIndex) + return false; + + const Token& nameToken = tokens[nameIndex]; + const Token& invocationToken = tokens[1 + startTokenIndex]; + + bool isGlobal = invocationToken.contents.compare("def-type-alias-global") == 0; + + std::vector typeOutput; + std::vector typeAfterNameOutput; + if (!(tokenizedCTypeToString_Recursive(tokens, typeIndex, true, typeOutput, + typeAfterNameOutput))) + { + return false; + } + addModifierToStringOutput(typeOutput.back(), StringOutMod_SpaceAfter); + + std::vector& outputDest = isGlobal ? output.header : output.source; + + addStringOutput(outputDest, "typedef", StringOutMod_SpaceAfter, &invocationToken); + PushBackAll(outputDest, typeOutput); + EvaluatorContext expressionContext = context; + expressionContext.scope = EvaluatorScope_ExpressionsOnly; + int numErrors = + EvaluateGenerate_Recursive(environment, expressionContext, tokens, nameIndex, output); + if (numErrors) + return false; + PushBackAll(outputDest, typeAfterNameOutput); + addLangTokenOutput(outputDest, StringOutMod_EndStatement, &invocationToken); + return true; +} + // I'm not too happy with this static void tokenizeGenerateStringTokenize(const char* outputVarName, const Token& triggerToken, const char* stringToTokenize, GeneratorOutput& output) @@ -1549,6 +1593,9 @@ void importFundamentalGenerators(EvaluatorEnvironment& environment) environment.generators["def-function-signature"] = DefFunctionSignatureGenerator; environment.generators["def-function-signature-local"] = DefFunctionSignatureGenerator; + environment.generators["def-type-alias"] = DefTypeAliasGenerator; + environment.generators["def-type-alias-global"] = DefTypeAliasGenerator; + environment.generators["defmacro"] = DefMacroGenerator; environment.generators["defgenerator"] = DefGeneratorGenerator;