jaredj/glotawk - Change KBD2A5MUJHKGV4JD6MLJXTKNAYZ5D44LX5WRB2ZXX5YCWBODWR3AC

keep reader state in local vars; add load and cell-info functions

Created by jaredj on September 3, 2025

KBD2A5MUJHKGV4JD6MLJXTKNAYZ5D44LX5WRB2ZXX5YCWBODWR3AC

Dependencies

In channels

main

Change contents

Replacement in repl.awk at line 16 [6.3599]

B:BD[4.459] → [5.67:130]

function _print_eval_all(     i, l) {
    l = length(_TO_EVAL)

[4.459]

[5.130]

function _print_eval_all(to_eval,     i, l) {
    l = length(to_eval)

Replacement in repl.awk at line 19 [6.3599]

B:BD[5.156] → [5.156:191]

        _print(_eval(_TO_EVAL[i]))

[5.156]

[4.643]

        _print(_eval(to_eval[i]))

Deletion in repl.awk at line 21 [6.3599]
B:BD[4.649] → [5.192:212]
```
    delete _TO_EVAL
```

Replacement in repl.awk at line 23 [6.3599]

B:BD[6.3869] → [5.213:276]

function _just_eval_all(      i, l) {
    l = length(_TO_EVAL)

[6.3869]

[5.276]

function _just_eval_all(to_eval,      i, l) {
    l = length(to_eval)

Replacement in repl.awk at line 26 [6.3599]
B:BD[5.302] → [5.302:329]
```
        _eval(_TO_EVAL[i])
```
[5.302]
[5.329]
```
        _eval(to_eval[i])
```
Deletion in repl.awk at line 28 [6.3599]
B:BD[5.335] → [5.335:355]
```
    delete _TO_EVAL
```

Replacement in repl.awk at line 32 [6.3599]

B:BD[5.392] → [5.392:418]

    _forget_parse_state()

[5.392]

[5.418]

    _forget_parse_state(_TOKENS, _WHERE, _INSIDE_STRING)

Replacement in repl.awk at line 41 [6.3599]

B:BD[5.659] → [5.659:870]

    # the reason to keep lists of parser state is so we can have forms
    # that span lines, rather than requiring each line of input to be
    # a complete form.
    tokenize($0)
    read_forms_into(_TO_EVAL)

[5.659]

[5.870]

    # the reason to keep global arrays of parser state (_TOKENS,
    # _TO_EVAL) is so we can have forms that span lines, rather than
    # requiring each line of input to be a complete form.
    tokenize($0, _TOKENS, _WHERE, _INSIDE_STRING)
    read_forms_into(_TO_EVAL, _TOKENS, _WHERE, _INSIDE_STRING)

Replacement in repl.awk at line 47 [6.3599]

B:BD[5.871] → [5.871:984]

    if(!FILENAME || (FILENAME == "-")) _print_eval_all()
    else                               _just_eval_all()

[5.871]

[5.984]

    if(!FILENAME || (FILENAME == "-")) _print_eval_all(_TO_EVAL)
    else                               _just_eval_all(_TO_EVAL)
    delete _TO_EVAL

Replacement in repl.awk at line 62 [6.3599]

B:BD[5.1279] → [5.1279:1310]

    _incomplete_parse_at_end()

[5.1279]

[5.1310]

    _incomplete_parse_at_end(_TOKENS, _WHERE, _INSIDE_STRING)

Replacement in reader.awk at line 16 [6.4015]

∅:D[3.1600] → [5.1313:1443]

B:BD[6.4058] → [5.1313:1443]

function _forget_parse_state() {
#    logg_dbg("_forget_parse_state")
    delete _TOKENS
    delete _WHERE
    _INSIDE_STRING = 0

[3.1600]

[5.1443]

function _forget_parse_state(tokens, where, inside_string) {
    delete tokens
    delete where
    inside_string[1] = 0

Replacement in reader.awk at line 22 [6.4015]
B:BD[5.1446] → [5.1446:1478]
```
function _push_token(t,    n) {
```
[5.1446]
[5.1478]
```
function _push_token(t, tokens, where,    n) {
```

Replacement in reader.awk at line 24 [6.4015]

B:BD[5.1510] → [5.1510:1588]

    n = length(_TOKENS)+1
    _TOKENS[n] = t
    _WHERE[n] = FILENAME ":" FNR

[5.1510]

[5.1588]

    n = length(tokens)+1
    tokens[n] = t
    where[n] = FILENAME ":" FNR

Replacement in reader.awk at line 29 [6.4015]

B:BD[5.1591] → [5.1591:1652]

function tokenize(input,      chars_done, chars_left, top) {

[5.1591]

[6.4120]

function tokenize(input, tokens, where, inside_string,     chars_done, chars_left, top) {

Replacement in reader.awk at line 33 [6.4015]

B:BD[6.4219] → [5.1653:1765]

#        logg_dbg("tokz", "input is [" input "]; inside string? " _INSIDE_STRING)
        top = length(_TOKENS)

[6.4219]

[5.1765]

#        logg_dbg("tokz", "input is [" input "]; inside string? " inside_string[1])
        top = length(tokens)

Replacement in reader.awk at line 38 [6.4015]
B:BD[5.1967] → [5.1967:1996]
```
        if(_INSIDE_STRING) {
```
[5.1967]
[5.1996]
```
        if(inside_string[1]) {
```

Replacement in reader.awk at line 40 [6.4015]

B:BD[5.2059] → [5.2059:2164]

                _TOKENS[top] = _TOKENS[top] substr(input, 1, RLENGTH)
                _INSIDE_STRING = 0

[5.2059]

[5.2164]

                tokens[top] = tokens[top] substr(input, 1, RLENGTH)
                inside_string[1] = 0

Replacement in reader.awk at line 44 [6.4015]

B:BD[5.2290] → [5.2290:2395]

                _TOKENS[top] = _TOKENS[top] substr(input, 1, RLENGTH)
                _INSIDE_STRING = 0

[5.2290]

[5.2395]

                tokens[top] = tokens[top] substr(input, 1, RLENGTH)
                inside_string[1] = 0

Replacement in reader.awk at line 50 [6.4015]

B:BD[5.2621] → [5.2621:2697]

                    _TOKENS[top] = _TOKENS[top] substr(input, 1, RLENGTH-1)

[5.2621]

[5.2697]

                    tokens[top] = tokens[top] substr(input, 1, RLENGTH-1)

Replacement in reader.awk at line 52 [6.4015]

B:BD[5.2722] → [5.2722:2781]

                    _TOKENS[top] = _TOKENS[top] input "\n"

[5.2722]

[5.2781]

                    tokens[top] = tokens[top] input "\n"

Replacement in reader.awk at line 64 [6.4015]

B:BD[5.3174] → [5.3174:3229]

                _push_token(substr(input, 1, RLENGTH))

[5.3174]

[5.3229]

                _push_token(substr(input, 1, RLENGTH), tokens, where)

Replacement in reader.awk at line 66 [6.4015]

B:BD[5.3303] → [5.3303:3358]

                _push_token(substr(input, 1, RLENGTH))

[5.3303]

[7.60]

                _push_token(substr(input, 1, RLENGTH), tokens, where)

Replacement in reader.awk at line 68 [6.4015]

∅:D[7.133] → [5.3435:3490]

B:BD[5.3435] → [5.3435:3490]

                _push_token(substr(input, 1, RLENGTH))

[7.133]

[7.134]

                _push_token(substr(input, 1, RLENGTH), tokens, where)

Replacement in reader.awk at line 71 [6.4015]

B:BD[5.3622] → [5.3622:3677]

                _push_token(substr(input, 1, RLENGTH))

[5.3622]

[5.3677]

                _push_token(substr(input, 1, RLENGTH), tokens, where)

Replacement in reader.awk at line 75 [6.4015]

B:BD[5.3870] → [5.3870:3931]

                    _push_token(substr(input, 1, RLENGTH-1))

[5.3870]

[5.3931]

                    _push_token(substr(input, 1, RLENGTH-1), tokens, where)

Replacement in reader.awk at line 77 [6.4015]

B:BD[5.3952] → [5.3952:4103]

                    _push_token(substr(input, 1, RLENGTH) "\n")
                _INSIDE_STRING = 1
#                logg_dbg("tokz", "_INSIDE_STRING")

[5.3952]

[7.218]

                    _push_token(substr(input, 1, RLENGTH) "\n", tokens, where)
                inside_string[1] = 1
#                logg_dbg("tokz", "inside_string[1]")

Replacement in reader.awk at line 81 [6.4015]

∅:D[7.289] → [5.4170:4225]

B:BD[5.4170] → [5.4170:4225]

                _push_token(substr(input, 1, RLENGTH))

[7.289]

[7.290]

                _push_token(substr(input, 1, RLENGTH), tokens, where)

Replacement in reader.awk at line 83 [6.4015]

∅:D[7.365] → [5.4304:4359]

B:BD[5.4304] → [5.4304:4359]

                _push_token(substr(input, 1, RLENGTH))

[7.365]

[5.4359]

                _push_token(substr(input, 1, RLENGTH), tokens, where)

Replacement in reader.awk at line 89 [6.4015]

B:BD[5.4589] → [5.4589:4631]

                    _forget_parse_state()

[5.4589]

[5.4631]

                    _forget_parse_state(tokens, where, inside_string)

Replacement in reader.awk at line 99 [6.4015]

B:BD[6.4983] → [5.4951:5003]

#        logg_dbg_array("tokz", "_TOKENS", _TOKENS)

[6.4983]

[5.5003]

#        logg_dbg_array("tokz", "tokens", tokens)

Replacement in reader.awk at line 111 [6.4015]

B:BD[5.5198] → [5.5198:5236]

                _forget_parse_state()

[5.5198]

[5.5236]

                _forget_parse_state(tokens, where, inside_string)

Replacement in reader.awk at line 147 [6.4015]

B:BD[5.6433] → [5.6433:6518]

function read_forms_into(rvs, a, b,  i, t, quote, topp, list_found, nesting_level) {

[5.6433]

[2.0]

function read_forms_into(rvs, tokens, where, inside_string,     a, b,  i, t, quote, topp, list_found, nesting_level) {

Replacement in reader.awk at line 153 [6.4015]
B:BD[5.6561] → [5.6561:6587]
```
        b=length(_TOKENS)
```
[5.6561]
[5.6587]
```
        b=length(tokens)
```

Replacement in reader.awk at line 155 [6.4015]

B:BD[5.6636] → [5.6636:6722]

        if(_INSIDE_STRING) b--
        topp=1   # we are the toplevel read_forms_into

[5.6636]

[8.605]

        if(inside_string[1]) b--
#        logg_dbg_array("read_forms_into", "tokens", tokens)
        topp=1   # we are a toplevel read_forms_into

Replacement in reader.awk at line 161 [6.4015]
B:BD[5.6861] → [5.6861:6884]
```
        t = _TOKENS[a]
```
[5.6861]
[5.6884]
```
        t = tokens[a]
```

Replacement in reader.awk at line 178 [6.4015]

B:BD[5.7466] → [5.7466:7579]

                if(_TOKENS[i] == "(") nesting_level++
                else if(_TOKENS[i] == ")") nesting_level--

[5.7466]

[5.7579]

                if(tokens[i] == "(") nesting_level++
                else if(tokens[i] == ")") nesting_level--

Replacement in reader.awk at line 188 [6.4015]

B:BD[5.7867] → [5.7867:7931]

                rvs[length(rvs)+1] = read_list(a+1, i-1, quote)

[5.7867]

[5.7931]

                rvs[length(rvs)+1] = read_list(tokens, a+1, i-1, quote, where, inside_string)

Replacement in reader.awk at line 201 [6.4015]

B:BD[5.8406] → [5.8406:8523]

            logg_err("read_forms_into", "too many )'s at " _WHERE[length(_WHERE)])
            _forget_parse_state()

[5.8406]

[5.8523]

            logg_err("read_forms_into", "too many )'s at " where[length(where)])
            _forget_parse_state(tokens, where, inside_string)

Replacement in reader.awk at line 206 [6.4015]

∅:D[7.695] → [5.8645:8698]

B:BD[5.8645] → [5.8645:8698]

            rvs[length(rvs)+1] = read_atom(a, quote)

[7.695]

[5.8698]

            rvs[length(rvs)+1] = read_atom(a, tokens, quote)

Replacement in reader.awk at line 213 [6.4015]

B:BD[5.8837] → [5.8837:8940]

        # we have read all the _TOKENS. but! maybe we are _INSIDE_STRING
        if(!_INSIDE_STRING) {

[5.8837]

[5.8940]

        # we have read all the tokens. but! maybe we are inside_string[1]
        if(!inside_string[1]) {

Replacement in reader.awk at line 216 [6.4015]

B:BD[5.8984] → [5.8984:9018]

            _forget_parse_state()

[5.8984]

[5.9018]

            _forget_parse_state(tokens, where, inside_string)

Replacement in reader.awk at line 226 [6.4015]

B:BD[5.9332] → [5.9332:9378]

    tokenize(s)
    read_forms_into(_TO_EVAL)

[5.9332]

[5.9378]

    tokenize(s, _TOKENS, _WHERE, _INSIDE_STRING)
    read_forms_into(_TO_EVAL, _TOKENS, _WHERE, _INSIDE_STRING)

Replacement in reader.awk at line 234 [6.4015]

B:BD[5.9482] → [5.9482:9546]

function read_list(a, b, quote,     i, forms, prevtail, head) {

[5.9482]

[6.5949]

function read_list(tokens, a, b, quote, where, inside_string,     i, forms, prevtail, head) {

Replacement in reader.awk at line 237 [6.4015]

B:BD[9.225] → [5.9565:9677]

    ## orientation: _TOKENS[a-1] == "(" and _TOKENS[b+1] == ")"
    if(((b-a+1) >= 3) && _TOKENS[b-1] == ".") {

[5.9564]

[5.9677]

    ## orientation: tokens[a-1] == "(" and tokens[b+1] == ")"
    if(((b-a+1) >= 3) && tokens[b-1] == ".") {

Replacement in reader.awk at line 241 [6.4015]

B:BD[5.9792] → [5.9792:9868]

        read_forms_into(forms, a, b-2)
        read_forms_into(forms, b, b)

[5.9792]

[5.9868]

        read_forms_into(forms, tokens, where, inside_string, a, b-2)
        read_forms_into(forms, tokens, where, inside_string, b, b)

Replacement in reader.awk at line 248 [6.4015]
∅:D[7.773] → [5.10044:10081]
B:BD[6.6676] → [5.10044:10081]
```
        read_forms_into(forms, a, b)
```
[7.773]
[5.10081]
```
        read_forms_into(forms, tokens, where, inside_string, a, b)
```

Replacement in reader.awk at line 261 [6.4015]

B:BD[6.6785] → [3.1601:1662]

function read_atom(a, quote,  this, ans, self_quoting, ch) {

[6.6785]

[6.6825]

function read_atom(a, tokens, quote,    this, ans, self_quoting, ch) {

Replacement in reader.awk at line 266 [6.4015]
B:BD[6.6987] → [5.10233:10255]
```
    this = _TOKENS[a]
```
[6.6987]
[7.774]
```
    this = tokens[a]
```

Replacement in reader.awk at line 318 [6.4015]

B:BD[6.7769] → [5.10497:10570]

function _incomplete_parse_at_end(      i, l, nesting_level, unclosed) {

[6.7769]

[5.10570]

function _incomplete_parse_at_end(tokens, where, inside_string,     i, l, nesting_level, unclosed) {

Replacement in reader.awk at line 320 [6.4015]
B:BD[5.10590] → [5.10590:10614]
```
    l = length(_TOKENS)
```
[5.10590]
[5.10614]
```
    l = length(tokens)
```
Replacement in reader.awk at line 322 [6.4015]
B:BD[5.10626] → [5.10626:10655]
```
        if(_INSIDE_STRING) {
```
[5.10626]
[5.10655]
```
        if(inside_string[1]) {
```

Replacement in reader.awk at line 324 [6.4015]

B:BD[5.10704] → [5.10704:10768]

                     "still inside string begun at " _WHERE[l])

[5.10704]

[5.10768]

                     "still inside string begun at " where[l])

Replacement in reader.awk at line 327 [6.4015]
B:BD[5.10808] → [5.10808:10844]
```
            if(_TOKENS[i] == "(") {
```
[5.10808]
[5.10844]
```
            if(tokens[i] == "(") {
```

Replacement in reader.awk at line 329 [6.4015]

B:BD[5.10893] → [5.10893:10936]

            } else if(_TOKENS[i] == ")") {

[5.10893]

[5.10936]

            } else if(tokens[i] == ")") {

Replacement in reader.awk at line 336 [6.4015]

B:BD[5.11147] → [5.11147:11281]

                         "still inside list (" _TOKENS[unclosed[i]+1] \
                         "... begun at " _WHERE[unclosed[i]])

[5.11147]

[5.11281]

                         "still inside list (" tokens[unclosed[i]+1] \
                         "... begun at " where[unclosed[i]])

Insertion in osf.awk at line 28 [11.954]

[10.787]

[11.3499]

    else if(car == _symbol("cell-info"))
        return _cons(_cons(_symbol("cells-ever"), _cons(_number(N), _nil())),
                     _cons(_cons(_symbol("cells-now"), _cons(_number(length(_TYPE)), _nil())),
                           _nil()))

Insertion in lib.glotawk at line 173 [14.36]
[12.1933]
[13.633]
```
(defintrinsic load (fn))
```

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

B:BD[11.17006] → [14.6092:6167]

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

[11.17006]

[16.692]

    _load(_string("lib.glotawk"))

Insertion in io.awk at line 42 [17.9773]

[17.11734]

    else if(car == _symbol("load"))
        return _load(_eval3(_cadr(form), env, env, d+1))

Insertion in io.awk at line 305 [17.9773]

[17.20175]

        return _nil()
    }
}
function _load(fn,       my_tokens, my_where, my_inside_string, my_to_eval) {
    # arrays
    delete my_tokens
    delete my_where
    delete my_inside_string
    delete my_to_eval
    if(_TYPE[fn] == "s") {
        # eval_read_str appears to work with multiple forms, but not
        # partial forms across calls. scarcely surprising.
        while((getline < _STRING[fn]) > 0) {
            tokenize($0, my_tokens, my_where, my_inside_string)
            read_forms_into(my_to_eval, my_tokens, my_where, my_inside_string)
            _just_eval_all(my_to_eval)      # may not contain anything
            delete my_to_eval
        }
        _incomplete_parse_at_end(my_tokens, my_where, my_inside_string)
        close(fn)
        return _true()
    } else {
        logg_err("_load", "filename to load from should be a string")

Insertion in first-symbols.awk at line 106 [11.17737]
[18.4027]
[17.20563]
```
    _symbol("load")
```
Insertion in first-symbols.awk at line 114 [11.17737]
[10.3900]
[11.19392]
```
    _symbol("cell-info")
```