jaredj/glotawk - Change O6PFGAUDYCMK6SC6V5RB5ELXZ7W54OB7XPYCMECCA4BSBUVLFAPAC

quasiquoting, indented logs, support for log levels per where-value; mapcar in awk did not work right, replacing with lisp version

Created by jaredj on June 13, 2025

O6PFGAUDYCMK6SC6V5RB5ELXZ7W54OB7XPYCMECCA4BSBUVLFAPAC

Dependencies

In channels

main

Change contents

Replacement in sane_lisp at line 128 [4.900]

∅:D[2.161] → [3.420:421]

B:BD[3.420] → [3.420:421]

[2.161]

[4.3557]

lisp_eval_should_be '(quasiquote (1 (unquote (+ 2 3)) 4))' '(1 5 4)' 'quasiquote with words'
lisp_eval_should_be '`(1 ,(+ 2 3) 4)' '(1 5 4)' 'quasiquote with reader syntax'

Replacement in logging.awk at line 5 [4.10323]
B:BD[4.10384] → [4.10384:10408]
```
function logg_setup() {
```
[4.10384]
[4.10408]
```
function logg_setup(       log_ats, i) {
```

Insertion in logging.awk at line 8 [4.10323]

[5.680]

[4.10508]

    delete CUSTOM_LEVEL[1]
    delete log_ats
    if(LOG_AT_ERR) {
        split(LOG_AT_ERR, log_ats, ",")
        for(i in log_ats) CUSTOM_LEVEL[log_ats[i]] = 1;
    }
    delete log_ats
    if(LOG_AT_INF) {
        split(LOG_AT_INF, log_ats, ",")
        for(i in log_ats) CUSTOM_LEVEL[log_ats[i]] = 2;
    }
    delete log_ats
    if(LOG_AT_DBG) {
        split(LOG_AT_DBG, log_ats, ",")
        for(i in log_ats) CUSTOM_LEVEL[log_ats[i]] = 3;
    }
    for(i in CUSTOM_LEVEL) {
        print "custom log level " CUSTOM_LEVEL[i] " for " i
}

Replacement in logging.awk at line 58 [4.10323]
B:BD[4.10787] → [3.1015:1045]
```
function represent_depth(d) {
```
[4.10787]
[3.1045]
```
function represent_depth(d,    to_rep) {
```

Replacement in logging.awk at line 60 [4.10323]

B:BD[3.1059] → [3.1059:1136]

    if(d in depth_representations) {
        return depth_representations[d]

[3.1059]

[3.1136]

    to_rep = d
    if(to_rep in depth_representations) {
        return depth_representations[to_rep]

Replacement in logging.awk at line 65 [4.10323]

B:BD[3.1185] → [3.1185:1235]

        return (depth_representations[d] = sp(d))

[3.1185]

[3.1235]

        return (depth_representations[to_rep] = sp(to_rep))

Replacement in logging.awk at line 69 [4.10323]

B:BD[3.1244] → [3.1244:1367]

function logg_dbg(where, x, d) {
    if(LOG_LEVEL >= 3)
        print "DBG" represent_depth(d) where ": " x >"/dev/stderr"

[3.1244]

[3.1367]

function logg_dbg(where, x, d,     lev) {
    lev = LOG_LEVEL
    if(where in CUSTOM_LEVEL)
        lev = CUSTOM_LEVEL[where]
    if(lev >= 3)
            print "DBG" represent_depth(d) where ": " x >"/dev/stderr"

Replacement in logging.awk at line 77 [4.10323]

B:BD[3.1370] → [3.1370:1493]

function logg_inf(where, x, d) {
    if(LOG_LEVEL >= 2)
        print "INF" represent_depth(d) where ": " x >"/dev/stderr"

[3.1370]

[3.1493]

function logg_inf(where, x, d,     lev) {
    lev = LOG_LEVEL
    if(where in CUSTOM_LEVEL)
        lev = CUSTOM_LEVEL[where]
    if(lev >= 2)
        if(!(where in NO_LOG))
            print "INF" represent_depth(d) where ": " x >"/dev/stderr"

Replacement in logging.awk at line 86 [4.10323]

B:BD[3.1496] → [3.1496:1552]

function logg_err(where, x, d) {
    if(LOG_LEVEL >= 1)

[3.1496]

[3.1552]

function logg_err(where, x, d,     lev) {
    lev = LOG_LEVEL
    if(where in CUSTOM_LEVEL)
        lev = CUSTOM_LEVEL[where]
    if(lev >= 1)

Insertion in lib-eval.awk at line 2 [5.21710]
[5.21773]
[5.21773]
```
#(setq mapcar (lambda (a b) (mapcar a b)))      \
```

Replacement in lib-eval.awk at line 37 [5.21710]

B:BD[5.23226] → [6.401:450]

B:BD[6.450] → [7.160:555]

∅:D[6.450] → [5.23687:23691]

∅:D[7.555] → [5.23687:23691]

B:BD[5.23687] → [5.23687:23691]

(setq mapcar (lambda (a b) (mapcar a b)))      \
(macro let (lambda (a)                         \
            (label ((vs (mapcar car (car a)))   \
                    (as (mapcar cadr (car a)))) \
              (append                            \
                (list (append                    \
                        (list (quote lambda) vs) \
                        (cdr a)))          \
                      as))))                  \
) \

[5.23226]

[5.23691]

(setq mapcar (lambda (f a)                     \
  (label ((map                                 \
            (lambda (a r)                      \
              (cond ((eq a nil) (nreverse r))  \
                    (true (map (cdr a)               \
                          (cons (f (car a)) r))))))) \
    (map a nil))))                                   \
(macro let (lambda (body)                                 \
            (label ((names (mapcar car (car body)))             \
                    (values (mapcar cadr (car body))))          \
              (list 'progn                                      \
                    '(print \"names\") (list 'print names)      \
                     (append                                    \
                      (list (append                         \
                             (list (quote lambda) names)    \
                             (cdr body)))                \
                      values)))))                        \
(macro q (lambda (x) (list (quote quote) (car x))))                     \
(macro quasiquote (lambda (lis)                                         \
                   (label ((qq1                                         \
                            (lambda (an)                                \
                              (cond ((atom an) an)                      \
                                    ((eq (car an) 'unquote) (eval (cadr an)))  \
                                    (true (mapcar qq1 an))))))          \
                     (cond ((atom (car lis)) (list 'quote (car lis)))   \
                           (true (list (quote quote)                    \
                                       (mapcar qq1 (car lis))))))))     \
)\

Insertion in eval.awk at line 141 [4.11057]

[3.3720]

[6.989]

    logg_dbg("_expand", "expanding " form " -> "_repr(form), depth)

Insertion in eval.awk at line 144 [4.11057]

[6.1078]

        logg_dbg("_expand", _repr(form) " is an atom", depth)

Replacement in eval.awk at line 154 [4.11057]

B:BD[6.1343] → [3.3721:3787]

                logg_dbg("_expand not macro", _repr(form), depth)

[6.1343]

                #logg_dbg("_expand not macro", _repr(form), depth)

Replacement in eval.awk at line 163 [4.11057]

B:BD[7.728] → [7.728:1063]

B:BD[7.1063] → [3.3856:3929]

                # apply, and we want to apply it to (list (list (quote
                # quote) (cdr form))). This thorny awk statement is
                # brought to you by the awkify elisp function in the
                # otherwise disused lib.awk, which proved to be not as
                # fast as saving an image in image.awk.
                logg_dbg("_expand macro call", "mpair is " _repr(mpair),

[7.728]

[3.3929]

                # apply, and we want to apply it to the quoted rest of
                # the form.
                #
                #logg_dbg("_expand macro call", "mpair is " _repr(mpair),
                #         depth+1)
                
                acc = _cons(_cadr(mpair),
                            _cons(_cons(_symbol("quote"),
                                        _cons(_cdr(form),
                                              _nil())),
                                  _nil()),
                            _nil())
                logg_dbg("_expand macro call", "_evaling " _repr(acc), depth)
                return _expand(_eval(acc, depth+1), depth+1)
            }
        }
    }
}
function _expand1(form, depth,     car, mpair, app, acc) {
    if(_truthy(_atom(form))) {
        return form
    } else {
        car = _car(form)
        if(car == _symbol("quote")) {
            return form
        } else {
            mpair = _assoc(car, _MACROS)
            if(_is_null(mpair)) {
                logg_dbg("_expand1 not macro", _repr(form), depth)
                # unlike expand, don't recurse in to find more macros
                return form
            } else {
                logg_dbg("_expand1 macro call", "mpair is " _repr(mpair),

Deletion in eval.awk at line 198 [4.11057]
B:BD[3.3963] → [3.3963:3980]
```
                
```

Replacement in eval.awk at line 206 [4.11057]

B:BD[3.4411] → [3.4411:4550]

                logg_dbg("_expand macro call", "_evaling " _repr(acc), depth)
                return _expand(_eval(acc, depth+1), depth+1)

[3.4411]

[7.1663]

                return _eval(acc, depth+1)

Replacement in eval.awk at line 209 [4.11057]
B:BD[7.1687] → [7.1687:1693]
```
    }
```
[7.1687]
[7.1693]
```
    }       
```

Replacement in eval.awk at line 238 [4.11057]

B:BD[4.14617] → [5.31150:31201]

                    return _evcon(_cdr(form), env)

[4.14617]

[4.14669]

                    return _evcon(_cdr(form), env, env, d+1)

Replacement in eval.awk at line 300 [4.11057]

∅:D[3.7861] → [5.34798:34847]

B:BD[5.34798] → [5.34798:34847]

                else if(car == _symbol("progn"))

[3.7861]

[3.7862]

                else if(car == _symbol("print")) {
                    _print(_eval3(_cadr(form), env, env, d+1))
                    return _nil()
                } else if(car == _symbol("progn"))

Replacement in eval.awk at line 305 [4.11057]

∅:D[3.7924] → [6.1797:1847]

B:BD[5.34904] → [6.1797:1847]

B:BD[6.1847] → [3.7925:8068]

∅:D[3.8068] → [6.1980:2020]

B:BD[6.1980] → [6.1980:2020]

                else if(car == _symbol("mapcar"))
                    return _mapcar(_eval3(_cadr(form), env, env, d+1),
                                   _eval3(_caddr(form), env, env, d+1),
                                   env)

[3.7924]

[6.2020]

#                else if(car == _symbol("mapcar"))
#                    return _mapcar(_eval3(_cadr(form), env, env, d+1),
#                                   _eval3(_caddr(form), env, env, d+1),
#                                   env, d+1)

Replacement in eval.awk at line 312 [4.11057]

∅:D[6.2194] → [5.34904:34951]

B:BD[5.34904] → [5.34904:34951]

                else if(car == _symbol("+")) {

[6.2194]

[3.8069]

                else if(car == _symbol("expand1"))
                    return _expand1(_eval3(_cadr(form), env, env, d+1),
                                    d+1)
                else if(car == _symbol("eval")) {
                    logg_dbg("_eval3 eval", "expression is " _cadr(form) " -> " _repr(_cadr(form)), d)
                    a = _eval3(_cadr(form), env, env, d+1)
                    logg_dbg("_eval3 eval", "value is " a " -> " _repr(a), d)
                    a = _eval3(a, env, env, d+1)
                    logg_dbg("_eval3 eval", "and that works out to " a " -> " _repr(a), d)
                    return a
                } else if(car == _symbol("+")) {

Replacement in data.awk at line 242 [4.16500]

B:BD[5.40889] → [6.3139:3185]

function _mapcar(fun, lis, env,   app, acc) {

[5.40889]

[6.3185]

# this is dead code. i tried to make it iterative and write it in awk
# so it would be faster, but it ended up eval-ing things too many
# times and i couldn't figure out where the problem was, even with
# copious debug logging.
function _mapcar(fun, lis, env, d,  v, app, acc) {

Insertion in data.awk at line 250 [4.16500]

[6.3241]

        # fun and lis are already evaluated
        logg_dbg("_mapcar", "fun: " _repr(fun) "; lis: " _repr(lis), d)

Replacement in data.awk at line 253 [4.16500]

B:BD[6.3300] → [6.3300:3407]

            app = _cons(fun, _cons(_car(lis), _nil()))
            acc = _cons(_eval3(app, env, env), acc)

[6.3300]

[6.3407]

            app = _cons(fun, _cons(_car(lis),
                                   _nil()))
            logg_dbg("_mapcar", "evaling: " _repr(app), d)
            v = _eval(app, d+1)
            logg_dbg("_mapcar", "result: " _repr(v))
            acc = _cons(v, acc)