jaredj/glotawk - Change FN5MOBGAHLSAECHXAJH3K54DOGLGUN7X7CAANQVCMP3ISA4B6YQAC

document assq; gsub with secret strings; split out _handle

Created by jaredj on November 24, 2025

FN5MOBGAHLSAECHXAJH3K54DOGLGUN7X7CAANQVCMP3ISA4B6YQAC

Dependencies

In channels

main

Change contents

Replacement in doc/releases.org at line 6 [7.37]

B:BD[6.1141] → [4.0:43]

rsprintf rprintf with-encrypted-input-from

[6.1141]

[6.1158]

rsprintf rprintf with-encrypted-input-from assq
** Bugs fixed
*** Backslash escapes on a continuation line ending a string
A bug in a regular expression in the tokenizer made it fail to
recognize the end of a string literal if there were backslash-escaped
characters on that line, particularly right before the ending
double-quote character. This is now tested for and fixed, and the code
and tests are commented.
*** assoc vs. assq
In previous versions, the assoc function, for searching an alist for
an association, was actually assq, because it used eq for comparison.
assoc is supposed to use equal. This has now been set straight: assq
uses eq, assoc uses equal.

Deletion in doc/releases.org at line 97 [7.37]

B:BD[6.4663] → [5.1408:1485]


** Bugs fixed
*** Backslash escapes on a continuation line ending a string

Deletion in doc/releases.org at line 98 [7.37]

B:BD[5.1486] → [5.1486:1777]

∅:D[5.1777] → [6.4663:4664]

B:BD[6.4663] → [6.4663:4664]

A bug in a regular expression in the tokenizer made it fail to
recognize the end of a string literal if there were backslash-escaped
characters on that line, particularly right before the ending
double-quote character. This is now tested for and fixed, and the code
and tests are commented.

Replacement in eval.awk at line 224 [8.11057]

B:BD[2.828] → [2.828:906]

        logg_err("_expand", "trying to expand nothing", depth)
        exit 3

[2.828]

[2.906]

        return _error(_cons(_string("trying to expand nothing"), _nil()))

Replacement in osf.awk at line 4 [9.954]

B:BD[9.956] → [10.2692:2783]

function _eval3_other_special_forms(form, env, d, hdlrs, st, errp,      car, a, no_errp) {

[9.956]

[9.1021]

function _eval3_other_special_forms(form, env, d, hdlrs, st, errp,      car, a) {

Replacement in osf.awk at line 49 [9.954]

B:BD[10.3977] → [10.3977:4574]

        hdlrs = _cons(_cadr(form), hdlrs) # unevaluated fwiw
        x = _evprog(_cddr(form), env, env, d+1, hdlrs, st, errp)
        if(errp[1]) {
            # don't pass a true errp in: the eval will quit
            delete no_errp
            no_errp[1] = 0
            return _eval3(_cons(_car(hdlrs),
                                _cons(_cons(_symbol("quote"),
                                            _cons(st, _nil())),
                                      _nil())),
                          env, env, d+1, _cdr(hdlrs), st, no_errp)
        } else  {
            return x
        }

[10.3977]

[10.4574]

        return _handle(_cdr(form), env, d+1, hdlrs, st, errp)

Insertion in osf.awk at line 71 [9.954]
[3.130]
[3.130]
```
    errp[2] = errform
```

Insertion in osf.awk at line 82 [9.954]

[3.647]

    }
}
function _handle(forms, env, d, hdlrs, st, errp,      x, no_errp, hp) {
    hdlrs = _cons(_car(forms), hdlrs) # unevaluated fwiw
    x = _evprog(_cdr(forms), env, env, d+1, hdlrs, st, errp)
    if(errp[1]) {
        logg_dbg("handle", "errp[2] is " errp[2], d)
        logg_dbg("handle", "which is " _repr(errp[2]), d)
        # don't pass a true errp in: the eval will quit
        delete no_errp
        no_errp[1] = 0
        hp = _cons(_cons(_keyword("evaltrace"),
                         _cons(st,
                               _nil())),
                   _cons(_cons(_keyword("errorform"),
                               _cons(errp[2],
                                     _nil())),
                         _nil()))
        logg_dbg("handle", "hp is " hp " which is " _repr(hp))
        return _eval3(_cons(_car(hdlrs),
                            _cons(_cons(_symbol("quote"),
                                        _cons(hp,
                                              _nil())),
                                  _nil())),
                      env, env, d+1, _cdr(hdlrs), st, no_errp)
    } else  {
        return x

Insertion in sane_lisp at line 291 [8.900]

[6.11683]

EXTRA_AWK_ARGS="-v KEY_FILE=keyfile" lisp_eval_should_be '(gsub "foo" S"bar" "foobarbaz")' 'S"(redacted)"' 'gsub with secret strings returns a secret string'
EXTRA_AWK_ARGS="-v KEY_FILE=keyfile" lisp_eval_should_be '(unsafe-reveal (gsub "foo" S"bar" "foobarbaz"))' '"barbarbaz"' 'gsub with secret strings returns the correct secret string'

Replacement in string.awk at line 7 [11.35]

B:BD[11.186] → [10.71:148]

        return _tolower(_eval3(_cadr(form), env, env, d+1, hdlrs, st, errp))

[11.186]

[11.246]

        return _tolower(_eval3(_cadr(form), env, env, d+1, hdlrs, st, errp),
                        env, d+1, hdlrs, st, errp)

Replacement in string.awk at line 10 [11.35]

B:BD[11.285] → [10.149:226]

        return _toupper(_eval3(_cadr(form), env, env, d+1, hdlrs, st, errp))

[11.285]

[11.345]

        return _toupper(_eval3(_cadr(form), env, env, d+1, hdlrs, st, errp),
                        env, d+1, hdlrs, st, errp)

Replacement in string.awk at line 90 [11.35]
B:BD[11.3153] → [11.3153:3184]
```
function _tolower(s,     tv) {
```
[11.3153]
[11.3184]
```
function _tolower(s, env, d, hdlrs, st, errp,     tv) {
```

Insertion in string.awk at line 93 [11.35]

[11.3254]

    } else if(_TYPE[s] == "S") {
        return _secret_string(tolower(_SECRET_STRING[s]))

Replacement in string.awk at line 96 [11.35]

B:BD[11.3267] → [11.3267:3350]

        logg_err("_tolower", "non-string operand " _repr(s))
        return _nil()

[11.3267]

[11.3350]

        return _error(_cons(_string("_tolower: cannot operate on %s"),
                            _cons(s, _nil())),
                      env, d, hdlrs, st, errp)

Replacement in string.awk at line 102 [11.35]
B:BD[11.3359] → [11.3359:3390]
```
function _toupper(s,     tv) {
```
[11.3359]
[11.3390]
```
function _toupper(s, env, d, hdlrs, st, errp,    tv) {
```

Insertion in string.awk at line 105 [11.35]

[11.3460]

    } else if(_TYPE[s] == "S") {
        return _secret_string(toupper(_SECRET_STRING[s]))

Replacement in string.awk at line 108 [11.35]

B:BD[11.3473] → [11.3473:3556]

        logg_err("_toupper", "non-string operand " _repr(s))
        return _nil()

[11.3473]

[11.3556]

        return _error(_cons(_string("_toupper: cannot operate on %s",
                                    _cons(s, _nil()))),
                      env, d, hdlrs, st, errp)

Insertion in string.awk at line 114 [11.35]

[11.3565]

# i got lazy. secret strings for tolower were a test balloon; toupper
# was due diligence; the real reason was gsub; and the rest i don't
# care about in late 2025

Replacement in string.awk at line 249 [11.35]

B:BD[11.6934] → [11.6934:7149]

B:BD[11.7149] → [10.2076:2077]

∅:D[10.2077] → [11.7149:7475]

B:BD[11.7149] → [11.7149:7475]

function _gsub3(r, t, s,   new_s, rv) {
    if(_TYPE[r] == "s") {
        if(_TYPE[t] == "s") {
            if(_TYPE[s] == "s") {
                # whoa nelly, destructive update.
                new_s = _STRING[s]
                gsub(_STRING[r], _STRING[t], new_s)
                return _string(new_s)
            } else {
                logg_err("_gsub3", "non-string s " _repr(s))
                return _nil()
            }
        } else {
            logg_err("_gsub3", "non-string t " _repr(t))
            return _nil()
        }

[11.6934]

[11.7475]

function _gsub3(r, t, s, env, d, hdlrs, st, errp,  secp, new_s, rv) {
    # most common case first and quickest:
    if(_TYPE[r] == "s" && _TYPE[t] == "s" && _TYPE[s] == "s") {
        # whoa nelly, destructive update.
        new_s = _STRING[s]
        gsub(_STRING[r], _STRING[t], new_s)
        return _string(new_s)

Replacement in string.awk at line 257 [11.35]

B:BD[11.7488] → [11.7488:7563]

        logg_err("_gsub3", "non-string r " _repr(r))
        return _nil()

[11.7488]

[11.7563]

        secp=0
        if(     _TYPE[r] == "s") r = _STRING[r]
        else if(_TYPE[r] == "S") { r = _SECRET_STRING[r]; secp=1; }
        else if(_TYPE[r] == "e") {
            r = _decrypt(_ENCRYPTED_STRING[r], env, d+1, hdlrs, st, errp)
            secp = 1
        } else return _error(_cons("_gsub3: cannot work with r param %s",
                                   _cons(r, _nil())),
                             env, d+1, hdlrs, st, errp)
        if(     _TYPE[t] == "s") t = _STRING[t]
        else if(_TYPE[t] == "S") { t = _SECRET_STRING[t]; secp=1; }
        else if(_TYPE[t] == "e") {
            t = _decrypt(_ENCRYPTED_STRING[t], env, d+1, hdlrs, st, errp)
            secp = 1
        } else return _error(_cons("_gsub3: cannot work with t param %s",
                                   _cons(t, _nil())),
                             env, d+1, hdlrs, st, errp)
        if(     _TYPE[s] == "s") s = _STRING[s]
        else if(_TYPE[s] == "S") { s = _SECRET_STRING[s]; secp=1; }
        else if(_TYPE[s] == "e") {
            s = _decrypt(_ENCRYPTED_STRING[s], env, d+1, hdlrs, st, errp)
            secp=1
        } else return _error(_cons("_gsub3: cannot work with s param %s",
                                   _cons(s, _nil())),
                             env, d+1, hdlrs, st, errp)
        # gsub destructively updates
        gsub(r, t, s)
        if(secp) return _secret_string(s)
        else return _string(s)