__________________________ CLEANING UP THE RPN CALC lro __________________________ <2019-01-07 Mon> Table of Contents _________________ Current architecture Saving user functions So Last post I alluded that I was going to clean things things up a bit and add a way to save any user define functions. Lets have a general look at how things work at the moment, then go from there. Current architecture ==================== At the moment, when the main loop encounters a function, it calls /run-func/ which checks if the `func' is the dictionary, and if it is run it otherwise print an error. And when the function is called, if its a primitive, the function is /rpn-func/, which takes a scheme function and how many arguments it needs, then /pop/s the appropriate number of arguments and calls the function on tose arguments and /push/es the result to the stack that is then returned. If a user defined function is called, then the list of functions is executed using /run-func/, and the altered stack passed along to the next function in the list. ,---- | +----------+ number +------------+ list +----------+ | +---| push |<------------| Main loop |-------->| new-func |----| | | +----------+ +------------+ +----------+ | | | ^ | ^ ^ | | +-----------------------------+ | | |--------------------------| | | | | | | | symbol | ------| | | | | +----------+ | | | run-func | | | +----------+ | | | | | | | | +------+ | | | func | | | +------+ | | | | | | | | +----------+ | | | rpn-func |---- | +----------+ `---- So its not terribly complex, but I would prefer if calling a function didn't jump thorugh so many hoops. But it isn't really that much abstraction. If I wanted to remove, I could write /rpn-func/ as a macro that expanded to a lambda that was juct the appropiate /let-values/ for many arguments the function took. For example: ,---- | (rpn-func + 2) `---- Would expand too: ,---- | (lambda (stack dict) | (let*-values (((var1 stack) (pop stack)) | ((var2 stack) (pop stack))) | (push (+ var1 var2) stack))) `---- Which would be awesome, but I don't know if it's worth it. For now I think i'll just keep things as they are with regards to function calls. I don't want to use macros to much, I think it would be best to try and keep them to a minimum, so I'm not going to build `init-dict' at compile time either, maybe in my next phlog post as a little detour I can go ham on the macros, both as practice and something interesting to phlog about. Saving user functions ===================== Looking at how I add user functions to the dictionary, it would be pretty easy to add some code to /new-func/ that writes the user functions to a file like /user-funcs/ and just write the lists to it. Then when we start the main loop, we can call a function that finds this file, and loads all the functions into the dictionary at start up. We can abuse/use read again by using /parameterize/ to make the standard input the /user-funcs/ file and add all the functions at startup using /new-func/. Unfortunately, there is no standard way in R7RS to append to a file, what bullshit. So we have some options: 1. read through the whole /user-funcs/ to get to the end. (slow) 2. just overwrite the file everytime we save. (stupid) 3. read /user-funcs/ in at startup, save to a string, and append new functions to that string, and saves that string to the file. We will go with number 3. So firstly we need a function to add a new user func to the /user-funcs/ string. I have used /parameterize/ so that I can use /display/ which will print our newlines correctly so that "your-funcs" has each function on a line. It then _overwrites_ the file with the old funcs and the new func, and returns that string as well. ,---- | (define (add-user-func list user-funcs file) | (let ((func-to-add (list-as-string list))) | (parameterize ((current-output-port (open-output-file file))) | (let ((new-user-funcs (string-append user-funcs func-to-add "\n"))) | (display new-user-funcs) | (close-output-port (current-output-port)) | new-user-funcs)))) `---- I needed a function that converted lists to a string, because schemes /list->string/ just converts a list of chars to one string. ,---- | (define (list-as-string list) | (parameterize ((current-output-port (open-output-string))) | (write list) | (get-output-string (current-output-port)))) `---- Now we can enter new functions to our save file, which is held in a variable. ,---- | (define funcs-file "your-funcs") `---- And now we need functions to retrieve the functions from the save file at the start of the main loop. ,---- | (define (load-funcs-from-file-dict file dict) | (with-input-from-file file | (lambda () | (let loop ((input (read)) | (dict dict)) | (if (eof-object? input) | dict | (loop (read) (new-func input dict))))))) | | (define (load-funcs-from-file-str file) | (with-input-from-file file | (lambda () | (let loop ((next-str (read-string 10)) | (str "")) | (if (eof-object? next-str) | str | (loop (read-string 10) (string-append str next-str))))))) `---- And our new main loop ,---- | (let loop ((input (read)) | (stack '()) | (dict (load-funcs-from-file-dict funcs-file init-dict)) | (user-funcs (load-funcs-from-file-str funcs-file))) | (cond | ((number? input) (loop (read) (push input stack) dict user-funcs)) | ((list? input) (let ((user-funcs (add-user-func input user-funcs funcs-file))) | (loop (read) stack (new-func input dict) user-funcs))) | ((symbol? input) (loop (read) (run-func input dict stack) dict user-funcs)) | (else (begin | (display "ERROR not valid input: ") | (display input) | (newline) | (loop (read) stack dict))))) `---- I also found a bud in my /update-alist/ function, it added an extra layer of parenthesis when updating functions. ,---- | (define (update-alist key new-val alist) | (let ((index (index-in-alist key alist))) | (list-set! alist index (cons key new-val)) | alist)) `---- So thats it for now, if anyone has any feature suggestions or patches or bug reports, feel free to email me, lro@sdf.org. Next time we might do some macro programming, or just actually go through and use this thing and do some cool RPN maths programming, we'll see.