A performance-oriented Lisp-like language where I can have my cake, and eat it (too)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

279 lines
15 KiB

(defmacro std-str-equals (std-string-var any str any)
(tokenize-push output (= 0 (on-call (token-splice std-string-var) compare (token-splice str))))
(return true))
;; This should evaluate its argument, but I'm just hacking it in right now anyways
(defmacro array-size (array-token symbol)
(tokenize-push output (/ (sizeof (token-splice array-token))
(sizeof (at 0 (token-splice array-token)))))
(return true))
;; Binds the variable's address to the named var
;; Note that this causes the caller's function to return false if the binding failed
;; TODO: This is madness, or close to it. All this for every comptime variable reference...
(defmacro get-or-create-comptime-var (bound-var-name (ref symbol) var-type (ref any)
&optional initializer-index (index any))
(unless (field environment moduleManager)
(return false))
(unless (ExpectTokenType "get-or-create-comptime-var" bound-var-name TokenType_Symbol)
(return false))
;; Only basing off of var-type for blaming
(var var-type-str Token var-type)
(set (field var-type-str type) TokenType_String)
(var destroy-var-func-name-str Token var-type)
(set (field destroy-var-func-name-str type) TokenType_String)
;; Convert type to parseable string as well as unique (to the type) function name
;; For parsing
(var type-to-string-buffer ([] 128 char) (array 0))
(var type-string-write-head (* char) type-to-string-buffer)
;; For function name
(var type-to-name-string-buffer ([] 128 char) (array 0))
(var type-name-string-write-head (* char) type-to-name-string-buffer)
(unless (writeStringToBufferErrorToken "destroy-"
(addr type-name-string-write-head) type-to-name-string-buffer
(sizeof type-to-name-string-buffer) var-type)
(return false))
(var current-type-token (* (const Token)) (addr var-type))
(var end-type-token (* (const Token)) (FindTokenExpressionEnd current-type-token))
(while (<= current-type-token end-type-token)
(unless (appendTokenToString (deref current-type-token) (addr type-string-write-head)
type-to-string-buffer (sizeof type-to-string-buffer))
(return false))
(when (= (path current-type-token > type) TokenType_Symbol)
((std-str-equals (path current-type-token > contents) "*")
(unless (writeStringToBufferErrorToken "ptr-to-"
(addr type-name-string-write-head) type-to-name-string-buffer
(sizeof type-to-name-string-buffer) (deref current-type-token))
(return false)))
((std-str-equals (path current-type-token > contents) "<>")
(unless (writeStringToBufferErrorToken "tmpl-of-"
(addr type-name-string-write-head) type-to-name-string-buffer
(sizeof type-to-name-string-buffer) (deref current-type-token))
(return false)))
((std-str-equals (path current-type-token > contents) "&")
(unless (writeStringToBufferErrorToken "ref-to-"
(addr type-name-string-write-head) type-to-name-string-buffer
(sizeof type-to-name-string-buffer) (deref current-type-token))
(return false)))
((std-str-equals (path current-type-token > contents) "[]")
(unless (writeStringToBufferErrorToken "array-of-"
(addr type-name-string-write-head) type-to-name-string-buffer
(sizeof type-to-name-string-buffer) (deref current-type-token))
(return false)))
((std-str-equals (path current-type-token > contents) "const")
(unless (writeStringToBufferErrorToken "const-"
(addr type-name-string-write-head) type-to-name-string-buffer
(sizeof type-to-name-string-buffer) (deref current-type-token))
(return false)))
;; Type names
(unless (writeStringToBufferErrorToken (on-call (path current-type-token > contents) c_str)
(addr type-name-string-write-head) type-to-name-string-buffer
(sizeof type-to-name-string-buffer) (deref current-type-token))
(return false)))))
(incr current-type-token))
(set (field var-type-str contents) type-to-string-buffer)
(var current-char (* char) type-to-name-string-buffer)
(while (!= (deref current-char) 0)
(when (= (deref current-char) ':')
(set (deref current-char) '-'))
(incr current-char))
(set (field destroy-var-func-name-str contents) type-to-name-string-buffer))
(var var-name Token bound-var-name)
(set (field var-name type) TokenType_String)
(var destroy-var-func-name-symbol Token destroy-var-func-name-str)
(set (field destroy-var-func-name-symbol type) TokenType_Symbol)
(var destroy-func-name (* (const char))
(on-call (field destroy-var-func-name-str contents) c_str))
;; Define the destructor if one for this type isn't already defined
(unless (or (findCompileTimeFunction environment destroy-func-name)
(findObjectDefinition environment destroy-func-name))
(var destruction-func-def (* (<> std::vector Token)) (new (<> std::vector Token)))
;; Need to have the environment delete this once it's safe
(on-call (field environment comptimeTokens) push_back destruction-func-def)
(tokenize-push (deref destruction-func-def)
(defun-comptime (token-splice-addr destroy-var-func-name-symbol) (data (* void))
(delete (type-cast data (* (token-splice-addr var-type))))))
(var destruction-func-context EvaluatorContext context)
;; This doesn't cause the required to propagate because comptime functions are lazily required,
;; even in module scope, because they're super slow to build (don't build if you don't use)
(set (field destruction-func-context isRequired) true)
(set (field destruction-func-context scope) EvaluatorScope_Module)
(set (field destruction-func-context definitionName)
(addr (path environment . moduleManager > globalPseudoInvocationName)))
;; We are only outputting a compile-time function, which uses definition's output storage to be
;; built. This throwaway will essentially only have a splice to that output, so we don't really
;; need to keep track of it, except to destroy it once everything is done
(var throwaway-output (* GeneratorOutput) (new GeneratorOutput))
(on-call (field environment orphanedOutputs) push_back throwaway-output)
(unless (= 0 (EvaluateGenerate_Recursive environment
(deref destruction-func-def) 0
(deref throwaway-output)))
(return false)))
(var initializer (<> std::vector Token))
(when (!= initializer-index -1)
(tokenize-push initializer (set (deref (token-splice-addr bound-var-name))
(token-splice-addr (at initializer-index tokens)))))
;; Create the binding and lazy-variable creation
;; TODO: Any way to make this less code for each ref? There's a lot here.
;; Yes: Auto-generate construction function and call it instead of copy-pasting
(tokenize-push output
(var (token-splice-addr bound-var-name) (* (token-splice-addr var-type)) null)
(scope (unless (GetCompileTimeVariable environment
(token-splice-addr var-name) (token-splice-addr var-type-str)
(type-cast (addr (token-splice-addr bound-var-name)) (* (* void))))
(set (token-splice-addr bound-var-name) (new (token-splice-addr var-type)))
(token-splice-array initializer)
(var destroy-func-name (* (const char)) (token-splice-addr destroy-var-func-name-str))
(unless (CreateCompileTimeVariable environment
(token-splice-addr var-name) (token-splice-addr var-type-str)
(type-cast (token-splice-addr bound-var-name) (* void))
(delete (token-splice-addr bound-var-name))
(return false)))))
(return true))
;; TODO: This is now built in, but it would still be useful to bind to arbitrary tokens
;; (defmacro destructure-arguments ()
;; (var end-invocation-index int (FindCloseParenTokenIndex tokens startTokenIndex))
;; ;; Find the end invocation for the caller, not us
;; (tokenize-push output
;; (var destr-end-invocation-index int
;; (FindCloseParenTokenIndex tokens startTokenIndex)))
;; (var start-args-index int (+ 2 startTokenIndex))
;; (var current-arg-index int start-args-index)
;; ;; Invocation is 0, so skip it
;; (var num-destructured-args int 1)
;; (while (< current-arg-index end-invocation-index)
;; (var current-arg (* (const Token)) (addr (at current-arg-index tokens)))
;; (var num-destructured-args-token Token (array TokenType_Symbol (std::to_string num-destructured-args)
;; "test/Macros.cake" 1 1 1))
;; (unless (ExpectTokenType "destructure-arguments" (at current-arg-index tokens) TokenType_Symbol)
;; (return false))
;; (var destructured-arg-name-token Token (array TokenType_String (field (at current-arg-index tokens) contents)
;; "test/Macros.cake" 1 1 1))
;; (tokenize-push output
;; (var (token-splice current-arg) int
;; (getExpectedArgument
;; ;; Use the name of the requested argument as the message
;; (token-splice (addr destructured-arg-name-token))
;; tokens startTokenIndex
;; (token-splice (addr num-destructured-args-token))
;; destr-end-invocation-index))
;; (when (= -1 (token-splice current-arg)) (return false)))
;; (++ num-destructured-args)
;; (set current-arg-index
;; (getNextArgument tokens current-arg-index end-invocation-index)))
;; (return true))
;; Assumes tokens is the array of tokens
(defmacro quick-token-at (name symbol index any)
(tokenize-push output (var (token-splice name) (& (const Token))
(at (token-splice index) tokens)))
(return true))
;; Creates forward declarations in header files.
;; Example usage:
;; (forward-declare (namespace Ogre (class item) (struct my-struct)))
;; Outputs namespace Ogre { class item; struct my-struct;}
(defgenerator forward-declare (&rest start-body-index (index any))
;; TODO: Support global vs local?
(var is-global bool true)
(var output-dest (& (<> std::vector StringOutput))
(? is-global (field output header) (field output source)))
(var end-invocation-index int (FindCloseParenTokenIndex tokens startTokenIndex))
(var current-index int start-body-index)
(var namespace-stack (<> std::vector int))
(while (< current-index end-invocation-index)
(var current-token (& (const Token)) (at current-index tokens))
;; Invocations
(when (= TokenType_OpenParen (field current-token type))
(var invocation-token (& (const Token)) (at (+ 1 current-index) tokens))
((= 0 (on-call (field invocation-token contents) compare "namespace"))
(unless (< (+ 3 current-index) end-invocation-index)
(ErrorAtToken invocation-token "missing name or body arguments")
(return false))
(var namespace-name-token (& (const Token)) (at (+ 2 current-index) tokens))
(addStringOutput output-dest "namespace"
StringOutMod_SpaceAfter (addr invocation-token))
(addStringOutput output-dest (field namespace-name-token contents)
StringOutMod_None (addr namespace-name-token))
(addLangTokenOutput output-dest StringOutMod_OpenBlock (addr namespace-name-token))
(on-call namespace-stack push_back (FindCloseParenTokenIndex tokens current-index)))
((or (= 0 (on-call (field invocation-token contents) compare "class"))
(= 0 (on-call (field invocation-token contents) compare "struct")))
(unless (< (+ 2 current-index) end-invocation-index)
(ErrorAtToken invocation-token "missing name argument")
(return false))
(var type-name-token (& (const Token)) (at (+ 2 current-index) tokens))
(unless (ExpectTokenType "forward-declare" type-name-token TokenType_Symbol)
(return false))
(addStringOutput output-dest (field invocation-token contents)
StringOutMod_SpaceAfter (addr invocation-token))
(addStringOutput output-dest (field type-name-token contents)
StringOutMod_None (addr type-name-token))
(addLangTokenOutput output-dest StringOutMod_EndStatement (addr type-name-token)))
(ErrorAtToken invocation-token "unknown forward-declare type")
(return false))))
(when (= TokenType_CloseParen (field current-token type))
(for-in close-block-index int namespace-stack
(when (= close-block-index current-index)
(addLangTokenOutput output-dest StringOutMod_CloseBlock
(addr (at current-index tokens))))))
;; TODO: Support function calls so we can do this recursively?
;; (set current-index
;; (getNextArgument tokens current-index end-invocation-index))
(incr current-index))
(return true))
(defmacro command-add-string-argument (command any new-argument any)
(tokenize-push output (on-call (field (token-splice command) arguments) push_back
(array ProcessCommandArgumentType_String
(token-splice new-argument))))
(return true))
;; See https://www.tutorialspoint.com/lisp/lisp_file_io.htm
;; (defmacro with-open-file ()
;; (destructure-arguments var-name-index file-name-index mode-index)
;; (quick-token-at var-name var-name-index)
;; (quick-token-at file-name file-name-index)
;; (quick-token-at mode mode-index)
;; (tokenize-push output
;; (scope
;; (var (token-splice-addr var-name) (* FILE)
;; (fopen (token-splice-addr file-name-index) (token-splice-addr mode-index)))))
;; (defun-local audio-dump-recorded-buffer ()
;; (var i int 0)
;; (var dest-file (* FILE) (fopen "out.dat" "w"))
;; (unless dest-file
;; (printf "Could not open file to write data\n")
;; (return))
;; (while (< i (array-size audio-input-buffer))
;; (fprintf dest-file "%d %d\n" i (at i audio-input-buffer))
;; (incr i))
;; (fclose dest-file))