jaredj/glotawk - Change I3MID22EURRK26C4JZ2U5FBEZ57GZVMBT44KFKTU4BBYXKLILWRAC

move glotawk library code out into its own file

Created by jaredj on August 26, 2025

I3MID22EURRK26C4JZ2U5FBEZ57GZVMBT44KFKTU4BBYXKLILWRAC

Dependencies

In channels

main

Change contents

File addition: lib.glotawk (----------)

[5.1]

;; -*- lisp -*-
;; SPDX-License-Identifier: BSD-2-Clause
(setq quote (lambda (a) (quote a)))
(setq atom (lambda (a) (atom a)))
(setq eq (lambda (a b) (eq a b)))
(setq car (lambda (a) (car a)))
(setq cdr (lambda (a) (cdr a)))
(setq cons (lambda (a b) (cons a b)))
(setq list (lambda a a))
(setq not (lambda (a) (not a)))
(setq null (lambda (a) (null a)))
(setq equal (lambda (a b) (equal a b)))
(setq caar (lambda (a) (caar a)))
(setq cadr (lambda (a) (cadr a)))
(setq cdar (lambda (a) (cdar a)))
(setq cddr (lambda (a) (cddr a)))
(setq memq (lambda (a b) (memq a b)))
(setq member (lambda (a b) (member a b)))
(setq assoc (lambda (a b) (assoc a b)))
(setq setq nil)
(setq caaar (lambda (a) (caaar a)))
(setq caadr (lambda (a) (caadr a)))
(setq cadar (lambda (a) (cadar a)))
(setq caddr (lambda (a) (caddr a)))
(setq cdaar (lambda (a) (cdaar a)))
(setq cdadr (lambda (a) (cdadr a)))
(setq cddar (lambda (a) (cddar a)))
(setq cdddr (lambda (a) (cdddr a)))
(setq rplaca (lambda (a b) (rplaca a b)))
(setq rplacd (lambda (a b) (rplacd a b)))
(setq nreverse (lambda (a) (nreverse a)))
(setq nconc (lambda (a b) (nconc a b)))
(setq append (lambda (a b) (append a b)))
(setq apply (lambda xs (apply xs)))
(setq string-length (lambda (s) (string-length s)))
(setq print (lambda (a) (print a)))
(setq progn nil)
(setq macro nil)
(setq expand1 (lambda (a) (expand1 a)))
(setq eval (lambda (a) (eval a)))
(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
                     (append
                      (list (append
                             (list (quote lambda) names)
                             (cdr body)))
                      values)))))
(macro q (lambda (x) (list (quote quote) (car x))))
(setq foldl (lambda (f z xs)
              (cond ((atom xs)       (f z xs))
                    ((null xs)       z)
                    ((null (cdr xs)) (f z (car xs)))
                    (true            (foldl f (f z (car xs))
                                            (cdr xs))))))
(setq reduce (lambda (f xs)
               (cond ((null xs) nil)
                     ((atom xs) xs)
                     ((null (cdr xs)) (car xs))
                     (true (foldl f (car xs) (cdr xs))))))
(setq mappend (lambda (f xs)
                (reduce append (mapcar f xs))))
(macro quasiquote (lambda (lis)
                   (label ((qq1
                            (lambda (an)
                              (cond ((atom an)
                                     (list 'list (list 'quote an)))
                                    ((eq (car an) 'unquote)
                                     (list 'list (cadr an)))
                                    ((eq (car an) 'unquote-splicing)
                                     (cadr an))
                                    (true (list 'list
                                                (list 'reduce 'append
                                                (cons 'list (mapcar qq1 an)))))
                                         ))))
                     (cond ((atom (car lis)) (list 'quote (car lis)))
                           (true (list 'reduce 'append
                                       (cons 'list
                                             (mapcar qq1 (car lis)))))))))
(macro let* (lambda (a)
             (cond ((null (car a)) `(progn ,@(cdr a)))
                   (true           `(let (,(caar a))
                                      (let* ,(cdar a)
                                        ,@(cdr a)))))))
(setq only2+ (lambda (a b) (only2+ a b)))
(setq + (lambda xs (foldl only2+ 0 xs)))
(setq only2* (lambda (a b) (only2* a b)))
(setq * (lambda xs (foldl only2* 1 xs)))
(setq only2- (lambda (a b) (only2- a b)))
(setq - (lambda xs (reduce only2- xs)))
(setq only2/ (lambda (a b) (only2/ a b)))
(setq / (lambda xs (reduce only2/ xs)))
(setq only2// (lambda (a b) (only2// a b)))
(setq // (lambda xs (reduce only2// xs)))
(setq only2% (lambda (a b) (only2% a b)))
(setq % (lambda xs (reduce only2% xs)))
(setq only2** (lambda (a b) (only2** a b)))
(setq ** (lambda xs (reduce only2** xs)))
(setq atan2 (lambda (a b) (atan2 a b)))
(setq cos (lambda (x) (cos x)))
(setq sin (lambda (x) (sin x)))
(setq exp (lambda (x) (exp x)))
(setq log (lambda (x) (log x)))
(setq sqrt (lambda (x) (sqrt x)))
(setq rand (lambda () (rand)))
(setq srand (lambda (x) (srand x)))
(setq int (lambda (x) (int x)))
(setq unsafe-system (lambda (x) (system x)))
(setq shellquote (lambda (x) (shellquote x)))
(setq intercalate (lambda (it them)
                          (cond ((null them))
                                ((null (cdr them)) them)
                                (true (cons (car them)
                                            (cons it
                                                  (intercalate it (cdr them))))))))
(setq string-join (lambda args (apply strcat (intercalate (car args) (cdr args)))))
(setq system (lambda argv (unsafe-system (apply string-join " " (mapcar shellquote argv)))))
(setq tolower (lambda (x) (tolower x)))
(setq toupper (lambda (x) (toupper x)))
(setq substr (lambda xs (cond ((eq (list-length xs 2))
                               (substr (car xs) (cadr xs)))
                              (true (substr (car xs) (cadr xs) (caddr xs))))))
(setq index (lambda (s t) (index s t)))
(setq match (lambda (s r) (match s r)))
(setq split (lambda (s fs) (split s fs)))
(setq sub (lambda (r t s) (sub r t s)))
(setq gsub (lambda (r t s) (gsub r t s)))
(setq sprintf nil)
(setq printf nil)
(setq strcat (lambda xs (strcat xs)))
(setq getline (lambda () (getline)))
(setq with-ors nil)
(setq with-output-to nil)
(setq with-input-from nil)
(setq fflush nil)
(setq close nil)
(setq gc-dot nil)
(setq gc nil)
(setq dump-dot nil)
(setq dump nil)

Deletion in lib-eval.awk at line 1 [6.21710]
B:BD[6.21710] → [7.362:363]
Deletion in lib-eval.awk at line 2 [6.21710]
B:BD[7.403] → [7.403:404]
∅:D[7.404] → [6.21711:21773]
B:BD[6.21710] → [6.21711:21773]
B:BD[6.21773] → [8.1572:1624]
```
# concise but quite slow: about 73ms at each startup (n=1000)
#(setq mapcar (lambda (a b) (mapcar a b)))      \
```

Replacement in lib-eval.awk at line 4 [6.21710]

B:BD[9.17006] → [3.11484:11505]

∅:D[3.11505] → [6.21804:22442]

B:BD[6.21804] → [6.21804:22442]

B:BD[6.22442] → [2.0:98]

∅:D[2.98] → [6.22442:22589]

B:BD[6.22442] → [6.22442:22589]

B:BD[6.22589] → [10.788:886]

∅:D[10.886] → [6.22589:23226]

B:BD[6.22589] → [6.22589:23226]

B:BD[6.23226] → [11.2061:2110]

∅:D[11.2110] → [10.887:1236]

B:BD[6.23226] → [10.887:1236]

B:BD[10.1236] → [3.11506:11510]

∅:D[3.11510] → [12.506:511]

B:BD[12.506] → [12.506:511]

B:BD[12.511] → [3.11511:11532]

∅:D[3.11532] → [12.533:542]

B:BD[12.533] → [12.533:542]

∅:D[12.542] → [8.1625:2244]

∅:D[10.1236] → [8.1625:2244]

B:BD[6.23226] → [8.1625:2244]

B:BD[8.2310] → [8.2310:2376]

B:BD[8.2376] → [12.543:839]

∅:D[12.839] → [8.2618:2692]

B:BD[8.2618] → [8.2618:2692]

B:BD[8.2692] → [12.840:1432]

B:BD[12.1432] → [13.953:1101]

∅:D[13.1101] → [12.1580:1802]

B:BD[12.1580] → [12.1580:1802]

∅:D[12.1802] → [8.2692:2914]

B:BD[8.2692] → [8.2692:2914]

B:BD[8.2914] → [13.1102:1250]

∅:D[13.1250] → [12.1897:1971]

B:BD[12.1897] → [12.1897:1971]

B:BD[12.1971] → [13.1251:1325]

∅:D[13.1325] → [12.2058:2132]

B:BD[12.2058] → [12.2058:2132]

B:BD[12.2132] → [13.1326:1704]

∅:D[13.1704] → [8.3143:3217]

B:BD[8.3143] → [8.3143:3217]

B:BD[8.3217] → [13.1705:1819]

∅:D[13.1819] → [12.2342:2419]

B:BD[12.2342] → [12.2342:2419]

B:BD[12.2419] → [14.235:605]

B:BD[14.605] → [3.11533:11537]

∅:D[3.11537] → [12.2424:2425]

B:BD[12.2424] → [12.2424:2425]

B:BD[12.2425] → [3.11538:11559]

∅:D[3.11559] → [12.2447:2456]

B:BD[12.2447] → [12.2447:2456]

∅:D[15.556] → [16.376:464]

∅:D[12.2456] → [16.376:464]

B:BD[16.376] → [16.376:464]

B:BD[16.464] → [17.0:87]

B:BD[17.87] → [15.557:1041]

B:BD[18.195] → [18.195:472]

B:BD[18.472] → [11.2111:2731]

∅:D[11.2731] → [18.512:596]

B:BD[18.512] → [18.512:596]

B:BD[18.596] → [9.17007:17334]

B:BD[9.17334] → [10.1237:1323]

B:BD[10.1323] → [19.5339:5398]

∅:D[19.5398] → [10.1324:1345]

B:BD[9.17480] → [10.1324:1345]

B:BD[10.1345] → [19.5399:5419]

∅:D[19.5419] → [10.1345:1385]

B:BD[10.1345] → [10.1345:1385]

B:BD[10.1385] → [20.781:842]

B:BD[20.842] → [19.5420:5448]

B:BD[19.5448] → [21.3720:3788]

∅:D[20.842] → [10.1385:1461]

∅:D[21.3788] → [10.1385:1461]

∅:D[19.5448] → [10.1385:1461]

B:BD[10.1385] → [10.1385:1461]

∅:D[17.87] → [8.3365:3368]

∅:D[16.464] → [8.3365:3368]

∅:D[18.596] → [8.3365:3368]

∅:D[15.1095] → [8.3365:3368]

∅:D[10.1461] → [8.3365:3368]

∅:D[9.17534] → [8.3365:3368]

B:BD[8.3365] → [8.3365:3368]

B:BD[8.3368] → [3.11560:11563]

    eval_read_str("\
(progn                                          \
(setq quote (lambda (a) (quote a)))            \
(setq atom (lambda (a) (atom a)))              \
(setq eq (lambda (a b) (eq a b)))              \
(setq car (lambda (a) (car a)))                \
(setq cdr (lambda (a) (cdr a)))                \
(setq cons (lambda (a b) (cons a b)))          \
(setq list (lambda a a))                       \
(setq not (lambda (a) (not a)))                \
(setq null (lambda (a) (null a)))              \
(setq equal (lambda (a b) (equal a b)))        \
(setq caar (lambda (a) (caar a)))              \
(setq cadr (lambda (a) (cadr a)))              \
(setq cdar (lambda (a) (cdar a)))              \
(setq cddr (lambda (a) (cddr a)))              \
(setq memq (lambda (a b) (memq a b)))          \
(setq member (lambda (a b) (member a b)))      \
(setq assoc (lambda (a b) (assoc a b)))        \
\"lol\"                                        \
(setq setq nil)                                \
(setq caaar (lambda (a) (caaar a)))            \
(setq caadr (lambda (a) (caadr a)))            \
(setq cadar (lambda (a) (cadar a)))            \
(setq caddr (lambda (a) (caddr a)))            \
(setq cdaar (lambda (a) (cdaar a)))            \
(setq cdadr (lambda (a) (cdadr a)))            \
(setq cddar (lambda (a) (cddar a)))            \
(setq cdddr (lambda (a) (cdddr a)))            \
(setq rplaca (lambda (a b) (rplaca a b)))      \
(setq rplacd (lambda (a b) (rplacd a b)))      \
(setq nreverse (lambda (a) (nreverse a)))      \
(setq nconc (lambda (a b) (nconc a b)))        \
(setq append (lambda (a b) (append a b)))      \
(setq apply (lambda xs (apply xs)))            \
(setq string-length (lambda (s) (string-length s))) \
(setq print (lambda (a) (print a)))            \
\"you can't use progn as a function, because.\" \
(setq progn nil)                               \
(setq macro nil)                               \
(setq expand1 (lambda (a) (expand1 a)))        \
(setq eval (lambda (a) (eval a)))              \
)")
    
    eval_read_str("\
(progn \
(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                                      \
                     (append                                    \
                      (list (append                                     \
                             (list (quote lambda) names)                \
                             (cdr body)))                               \
                      values)))))                                       \
(macro q (lambda (x) (list (quote quote) (car x))))                     \
(setq foldl (lambda (f z xs)                                            \
              (cond ((atom xs)       (f z xs))                          \
                    ((null xs)       z)                                 \
                    ((null (cdr xs)) (f z (car xs)))                    \
                    (true            (foldl f (f z (car xs))            \
                                            (cdr xs))))))               \
(setq reduce (lambda (f xs)                                             \
               (cond ((null xs) nil)                                    \
                     ((atom xs) xs)                                     \
                     ((null (cdr xs)) (car xs))                         \
                     (true (foldl f (car xs) (cdr xs))))))              \
(setq mappend (lambda (f xs)                                            \
                (reduce append (mapcar f xs))))                         \
(macro quasiquote (lambda (lis)                                         \
                   (label ((qq1                                         \
                            (lambda (an)                                \
                              (cond ((atom an)                          \
                                     (list 'list (list 'quote an)))     \
                                    ((eq (car an) 'unquote)             \
                                     (list 'list (cadr an)))            \
                                    ((eq (car an) 'unquote-splicing)    \
                                     (cadr an))                        \
                                    (true (list 'list                   \
                                                (list 'reduce 'append   \
                                                (cons 'list (mapcar qq1 an))))) \
                                         ))))                            \
                     (cond ((atom (car lis)) (list 'quote (car lis)))   \
                           (true (list 'reduce 'append     \
                                       (cons 'list \
                                             (mapcar qq1 (car lis))))))))) \
(macro let* (lambda (a)                                                 \
             (cond ((null (car a)) `(progn ,@(cdr a)))                  \
                   (true           `(let (,(caar a))                    \
                                      (let* ,(cdar a)                   \
                                        ,@(cdr a)))))))                 \
)")
    eval_read_str("\
(progn \
(setq only2+ (lambda (a b) (only2+ a b))) \
(setq + (lambda xs (foldl only2+ 0 xs)))  \
(setq only2* (lambda (a b) (only2* a b))) \
(setq * (lambda xs (foldl only2* 1 xs))) \
(setq only2- (lambda (a b) (only2- a b))) \
(setq - (lambda xs (reduce only2- xs)))   \
(setq only2/ (lambda (a b) (only2/ a b))) \
(setq / (lambda xs (reduce only2/ xs)))   \
(setq only2// (lambda (a b) (only2// a b))) \
(setq // (lambda xs (reduce only2// xs))) \
(setq only2% (lambda (a b) (only2% a b))) \
(setq % (lambda xs (reduce only2% xs))) \
(setq only2** (lambda (a b) (only2** a b))) \
(setq ** (lambda xs (reduce only2** xs))) \
(setq atan2 (lambda (a b) (atan2 a b))) \
(setq cos (lambda (x) (cos x))) \
(setq sin (lambda (x) (sin x))) \
(setq exp (lambda (x) (exp x))) \
(setq log (lambda (x) (log x))) \
(setq sqrt (lambda (x) (sqrt x))) \
(setq rand (lambda () (rand))) \
(setq srand (lambda (x) (srand x))) \
(setq int (lambda (x) (int x))) \
(setq unsafe-system (lambda (x) (system x))) \
(setq shellquote (lambda (x) (shellquote x))) \
(setq intercalate (lambda (it them) \
                          (cond ((null them)) \
                                ((null (cdr them)) them) \
                                (true (cons (car them) \
                                            (cons it \
                                                  (intercalate it (cdr them)))))))) \
(setq string-join (lambda args (apply strcat (intercalate (car args) (cdr args))))) \
(setq system (lambda argv (unsafe-system (apply string-join \" \" (mapcar shellquote argv)))))\
(setq tolower (lambda (x) (tolower x))) \
(setq toupper (lambda (x) (toupper x))) \
(setq substr (lambda xs (cond ((eq (list-length xs 2)) \
                               (substr (car xs) (cadr xs))) \
                              (true (substr (car xs) (cadr xs) (caddr xs))))))\
(setq index (lambda (s t) (index s t))) \
(setq match (lambda (s r) (match s r))) \
(setq split (lambda (s fs) (split s fs))) \
(setq sub (lambda (r t s) (sub r t s))) \
(setq gsub (lambda (r t s) (gsub r t s))) \
\"no printf/sprintf function values, i've got no apply\" \
(setq sprintf nil) \
(setq printf nil) \
(setq strcat (lambda xs (strcat xs))) \
(setq getline (lambda () (getline))) \
(setq with-ors nil) \
(setq with-output-to nil) \
(setq with-input-from nil) \
(setq fflush nil) \
(setq close nil) \
(setq gc-dot nil) \
(setq gc nil) \
(setq dump-dot nil) \
(setq dump nil) \
)\
")

[9.17006]

[22.692]

    while((getline < "lib.glotawk") > 0) {
        eval_read_str($0)
    }

Deletion in lib-eval.awk at line 10 [6.21710]

B:BD[22.818] → [11.2732:2843]

    _GLOBALS = _cons(_cons(_symbol("a-newline"), _cons(_string("\n"), _nil())),
                     _GLOBALS)

Deletion in lib-eval.awk at line 11 [6.21710]

B:BD[6.23697] → [23.451:937]


# (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))))

Replacement in Makefile at line 4 [24.23921]
B:BD[22.3108] → [4.476:495]
∅:D[4.495] → [25.1035:1055]
B:BD[25.1035] → [25.1035:1055]
```
AWK = original-awk
#AWK = original-awk
```
[22.3108]
[25.1055]
```
AWK = /usr/bin/original-awk
```