Global ___clock_thread (void *arg)

: a better implementation would be to analyze the semtrex expectations that have been planted and only wakeup when needed based on those semtrexes

Global __m_add_level (M *m)

make this not realloc each time?

Global __m_add_nodes (H h, L *l, int c)

make this not realloc each time!!

Global __p_addrt2q (Q *q, T *t, T *sem_map)

make thread safe. currently you shouldn't call this if the Q is being actively reduced

Global __p_addrt2q (Q *q, T *t, T *sem_map)

make thread safe. currently you shouldn't call this if the Q is being actively reduced

Global __p_check_signature (SemTable *sem, Process p, T *params, T *sem_map)

add SIGNATURE_SYMBOL for setting up process signatures by Symbol not just Structure

Global __p_check_signature (SemTable *sem, Process p, T *params, T *sem_map)

add SIGNATURE_SYMBOL for setting up process signatures by Symbol not just Structure

Global __p_make_form (Symbol sym, char *output_label, Symbol output_type, SemanticID output_sem,...)

add more sensible handling of output signature. We still aren't quite sure what to do about the output label, and how to handle output signature pass through from the results, probably need a special symbol for that

Global __p_reduce_sys_proc (R *context, Symbol s, T *code, Q *q)

what happens if it has more than one child! validity check?

this would probably be faster with just one total realloc for all children

what happens if it has more than one child! validity check?

interpolation errors?

what should this really return?

the value returned from the iteration will be what??(what's in x)

this would probably be faster with just one total realloc for all children

what happens if it has more than one child! validity check?

interpolation errors?

what should this really return?

the value returned from the iteration will be what??(what's in x)

Global __r_make_signal (ReceptorAddress from, ReceptorAddress to, Aspect aspect, Symbol carrier, T *signal_contents, UUIDt *in_response_to, T *until, T *conversation)

signal should have timestamps

Global __st_scan (Stream *st)

allow other delimiters, or even simply a length, to mark off a unit.

Global __t_morph (T *t, Symbol s, void *surface, size_t length, int allocate)

Handle the case where the surface of the node to be morphed is itself a tree

Global __t_serialize (SemTable *sem, T *t, void **bufferP, size_t offset, size_t current_size, int compact)

compact is really a shorthand for whether this is a fixed size tree or not this should actually be determined on the fly by looking at the structure types.

Global _d_build_def_semtrex (SemTable *sem, Symbol s, T *parent)

currently this won't detect an incorrect strcture with extra children. This is because we don't haven't yet implemented the equivalent of "$" for semtrex.

Global _d_define_process (SemTable *sem, T *code, char *name, char *intention, T *signature, T *link, Context c)

this is not thread safe!

Global _d_define_symbol (SemTable *sem, Structure s, char *label, Context c)

this is not thread safe!

Global _d_make_process_def (T *code, char *name, char *intention, T *signature, T *link)

this is not thread safe!

Global _m_walk (H h, void(*walkfn)(H, N *, void *, MwalkState *, Maddr), void *user_data)

checks to make sure root isn't deleted or null?

Global _p_fill_from_match (SemTable *sem, T *t, T *match_results, T *match_tree)

what to do if match has sibs??

Global _p_reduceq (Q *q)

figure out what error we should be sending back here, i.e. what if

Global _p_step (Q *q, R **contextP)

what if the replaced parameter is itself a PARAM_REF tree ??

Global _r_def_match (Receptor *r, Symbol s, T *t)

currently this just matches on a semtrex. It should also look at the surface sizes to see if they meet the criteria of the structure definitions.

Global _r_deliver (Receptor *r, T *signal)

for now the signal param is added directly to the flux. Later it should probably be cloned? or there should be a parameter to choose?

Global _r_new_instance (Receptor *r, T *t)

currently stores instances in a hash of hashes, this will later be handled by interacting with the data-engine.

Global _r_new_receptor_from_package (SemTable *sem, Symbol s, T *p, T *bindings)

implement bindings

Global _r_request (Receptor *r, T *signal, Symbol response_carrier, T *code_point, int process_id, T *cid)

signal should have timestamps and other meta info

Global _t_free (T *t)

make this remove the child from the parent's child-list?

Global _t_get_path (T *t)

implement jumping into orthogonal trees (i.e. return paths with 0 in them)

Parameters

[in] t tree node

Returns: path of node

Global _t_next_sibling (T *t)

improve algorithm as this is very expensive if called all the time.

Global _t_path_walk (T *t, int **pathP, int *lenP)

optimize reallocing

Global _v_deliver_signals (VMHost *v, Receptor *sender)

this should probably be implemented in a scape but for now

Global _v_install_r (VMHost *v, Xaddr package, T *bindings, char *label)

expand the manifest to allow optional binding, etc, using semtrex to do the matching instead of assuming positional matching

Global _v_load_receptor_package (VMHost *v, T *p)

validate signature and checksums??

Global _val_match (T *t, T *t1)

move this to tree.c

File def.c

refactor symbol/structure/process definition mechanisms into a general definitional form

Global parseSemtrex (SemTable *sem, char *stx)

, this should be implemented using template filling?

File process.c

implement a way to define sys_processes input and output signatures

Global testProcessIf ()

when interpolating from a match, how do we handle non-leaf interpollations, i.e. where do you hook children onto?

Global testProcessIntMath ()

structure type checking for integer math? Too expensive?