Just made some tests and it works pretty well within a loadable builtin I am working on:



Thanks again for mantaining this project btw! Without it I probably would never have learned C!

Cheers

yes I do. I am working on a json bash loadable to query and render json data via associative arrays. so there's no need for a shell interface like ksh93.

Thanks, I'll implement unset hook first. Usually further ideas come up during work, hopefully.

Btw what do you think about adding SHELL_VAR pointers to ARRAY and HASH_TABLE? So we can inject according 'sh_var_cell_func_t' (as proposed below) into 'array_reference' and 'assoc_reference'. Anyhow it feels a bit like a workaround though...

typedef struct hash_table {
  BUCKET_CONTENTS *bucket_array; / Where the data is kept. */
  SHELL_VAR var;                / To which variable does data belong. */
  int nbuckets; /* How many buckets does this table have. */
  int nentries; /* How many entries does this table have. */
} HASH_TABLE;

typedef struct array {
arrayind_t max_index;
arrayind_t num_elements;
#ifdef ALT_ARRAY_IMPLEMENTATION
arrayind_t first_index;
arrayind_t alloc_size;
struct array_element **elements;
#else
struct array_element *head;
struct array_element *lastref;
#endif
        SHELL_VAR var;                / To which variable does array belong. */
} ARRAY;

comment #1:

> Thanks for the suggestion.

I'd be thankful for any architectural hint/direction so I can implement a proposing solution on my own and open a merge request.

Though the current interface in this regard is very useful there are situations where it is incomplete. Especially when dynamic variable cells shall be assigned on demand. For example $ echo ${a_configuration_json[key]}; or $ unset a_configuration_json[key]; could perform a query in /a/configuration.json by the given key without reading the whole file into memory at once.

Current interface functions are defined as

typedef struct variable sh_var_value_func_t PARAMS((struct variable ));
typedef struct variable sh_var_assign_func_t PARAMS((struct variable , char , arrayind_t, char ));

furthermore the following definition I'd consider more complete

typedef struct variable sh_var_value_func_t PARAMS((struct variable , char *, arrayind_t));
typedef struct variable sh_var_assign_func_t PARAMS((struct variable , char , arrayind_t, char ));
typedef struct variable sh_var_unassign_func_t PARAMS((struct variable , char *, arrayind_t));

but as far as I can judge the current architecture makes it uneasy to achieve a more specific assign function. That is because now assign function is called with every variable lookup in general, but not every single variable value (array, hash table) lookup. Which makes especially sense performance wise.

Therefore I'd suggest an additional interface looking something like

typedef struct variable sh_var_value_func_t PARAMS((struct variable ));
typedef struct variable sh_var_cell_func_t PARAMS((struct variable , char *, arrayind_t));
typedef struct variable sh_var_assign_func_t PARAMS((struct variable , char , arrayind_t, char ));
typedef struct variable sh_var_unassign_func_t PARAMS((struct variable , char *, arrayind_t));

A read function of type sh_var_cell_func_t could be called from within

extern char array_reference PARAMS((ARRAY , arrayind_t));

and

extern char assoc_reference PARAMS((HASH_TABLE , char *));

if SHELL_VAR* has an appropriate member assigned. The main problem I suspect here is that neither array_reference nor assoc_reference are aware of the current SHELL_VAR* to check either for the function assginment nor to pass SHELL_VAR* to sh_var_cell_func_t.

Unfortunately my current knowledge of bash architecture is insufficient to measure up further steps on my own.

Kind regards

Dominik Kummer