summaryrefslogtreecommitdiff
path: root/vere/pkg/noun/retrieve.h
diff options
context:
space:
mode:
authorpolwex <polwex@sortug.com>2025-10-05 21:56:51 +0700
committerpolwex <polwex@sortug.com>2025-10-05 21:56:51 +0700
commitfcedfddf00b3f994e4f4e40332ac7fc192c63244 (patch)
tree51d38e62c7bdfcc5f9a5e9435fe820c93cfc9a3d /vere/pkg/noun/retrieve.h
claude is gud
Diffstat (limited to 'vere/pkg/noun/retrieve.h')
-rw-r--r--vere/pkg/noun/retrieve.h547
1 files changed, 547 insertions, 0 deletions
diff --git a/vere/pkg/noun/retrieve.h b/vere/pkg/noun/retrieve.h
new file mode 100644
index 0000000..c02c008
--- /dev/null
+++ b/vere/pkg/noun/retrieve.h
@@ -0,0 +1,547 @@
+/// @file
+
+#ifndef U3_RETRIEVE_H
+#define U3_RETRIEVE_H
+
+#include "c3/c3.h"
+#include "allocate.h"
+#include "error.h"
+#include "gmp.h"
+#include "types.h"
+
+ /** u3r_*: read without ever crashing.
+ **/
+
+ /* u3r_cell(): factor (a) as a cell (b c).
+ */
+ inline c3_o
+ u3r_cell(u3_noun a, u3_noun* b, u3_noun* c)
+ {
+ u3a_cell* cel_u;
+
+ u3_assert(u3_none != a);
+
+ if ( c3y == u3a_is_cell(a) ) {
+ cel_u = u3a_to_ptr(a);
+ if ( b ) *b = cel_u->hed;
+ if ( c ) *c = cel_u->tel;
+ return c3y;
+ }
+ else {
+ return c3n;
+ }
+ }
+
+ /* u3r_trel(): factor (a) as a trel (b c d).
+ */
+ inline c3_o
+ u3r_trel(u3_noun a, u3_noun *b, u3_noun *c, u3_noun *d)
+ {
+ u3_noun guf;
+
+ if ( (c3y == u3r_cell(a, b, &guf)) &&
+ (c3y == u3r_cell(guf, c, d)) ) {
+ return c3y;
+ }
+ else {
+ return c3n;
+ }
+ }
+
+ /* u3r_qual(): factor (a) as a qual (b c d e).
+ */
+ inline c3_o
+ u3r_qual(u3_noun a,
+ u3_noun* b,
+ u3_noun* c,
+ u3_noun* d,
+ u3_noun* e)
+ {
+ u3_noun guf;
+
+ if ( (c3y == u3r_cell(a, b, &guf)) &&
+ (c3y == u3r_trel(guf, c, d, e)) ) {
+ return c3y;
+ }
+ else return c3n;
+ }
+
+ /* u3r_quil(): factor (a) as a quil (b c d e f).
+ */
+ inline c3_o
+ u3r_quil(u3_noun a,
+ u3_noun* b,
+ u3_noun* c,
+ u3_noun* d,
+ u3_noun* e,
+ u3_noun* f)
+ {
+ u3_noun guf;
+
+ if ( (c3y == u3r_cell(a, b, &guf)) &&
+ (c3y == u3r_qual(guf, c, d, e, f)) ) {
+ return c3y;
+ }
+ else return c3n;
+ }
+
+ /* u3r_hext(): factor (a) as a hext (b c d e f g)
+ */
+ inline c3_o
+ u3r_hext(u3_noun a,
+ u3_noun* b,
+ u3_noun* c,
+ u3_noun* d,
+ u3_noun* e,
+ u3_noun* f,
+ u3_noun* g)
+ {
+ u3_noun guf;
+
+ if ( (c3y == u3r_cell(a, b, &guf)) &&
+ (c3y == u3r_quil(guf, c, d, e, f, g)) ) {
+ return c3y;
+ }
+ else return c3n;
+ }
+
+ /* u3r_at(): fragment `a` of `b`, or u3_none.
+ */
+ u3_weak
+ u3r_at(u3_atom a, u3_weak b);
+
+ /* u3r_mean():
+ **
+ ** Attempt to deconstruct `a` by axis, noun pairs; 0 terminates.
+ ** Axes must be sorted in tree order.
+ */
+ c3_o
+ u3r_vmean(u3_noun a, va_list ap);
+ c3_o
+ u3r_mean(u3_noun a, ...);
+
+ /* u3r_mug_both(): Join two mugs.
+ */
+ c3_l
+ u3r_mug_both(c3_w lef_w, c3_w rit_w);
+
+ /* u3r_mug_bytes(): Compute the mug of `buf`, `len`, LSW first.
+ */
+ c3_l
+ u3r_mug_bytes(const c3_y *buf_y,
+ c3_w len_w);
+
+ /* u3r_mug_c(): Compute the mug of `a`, LSB first.
+ */
+ c3_l
+ u3r_mug_c(const c3_c *a_c);
+
+ /* u3r_mug_cell(): Compute the mug of the cell `[hed tel]`.
+ */
+ c3_l
+ u3r_mug_cell(u3_noun hed,
+ u3_noun tel);
+
+ /* u3r_mug_chub(): Compute the mug of `num`, LSW first.
+ */
+ c3_l
+ u3r_mug_chub(c3_d num_d);
+
+ /* u3r_mug_words(): 31-bit nonzero MurmurHash3 on raw words.
+ */
+ c3_l
+ u3r_mug_words(const c3_w* key_w, c3_w len_w);
+
+ /* u3r_mug(): statefully mug a noun with 31-bit murmur3.
+ */
+ c3_l
+ u3r_mug(u3_noun veb);
+
+ /* u3r_fing():
+ **
+ ** Yes iff (a) and (b) are the same copy of the same noun.
+ ** (Ie, by pointer equality - u3r_sing with false negatives.)
+ */
+ c3_o
+ u3r_fing(u3_noun a,
+ u3_noun b);
+
+ /* u3r_fing_cell():
+ **
+ ** Yes iff `[p q]` and `b` are the same copy of the same noun.
+ */
+ c3_o
+ u3r_fing_cell(u3_noun p,
+ u3_noun q,
+ u3_noun b);
+
+ /* u3r_fing_mixt():
+ **
+ ** Yes iff `[p q]` and `b` are the same copy of the same noun.
+ */
+ c3_o
+ u3r_fing_mixt(const c3_c* p_c,
+ u3_noun q,
+ u3_noun b);
+
+ /* u3r_fing_trel():
+ **
+ ** Yes iff `[p q r]` and `b` are the same copy of the same noun.
+ */
+ c3_o
+ u3r_fing_trel(u3_noun p,
+ u3_noun q,
+ u3_noun r,
+ u3_noun b);
+
+ /* u3r_fing_qual():
+ **
+ ** Yes iff `[p q r s]` and `b` are the same copy of the same noun.
+ */
+ c3_o
+ u3r_fing_qual(u3_noun p,
+ u3_noun q,
+ u3_noun r,
+ u3_noun s,
+ u3_noun b);
+
+ /* u3r_sing(): noun value equality.
+ **
+ ** Unifies noun pointers on inner roads.
+ */
+ c3_o
+ u3r_sing(u3_noun a, u3_noun b);
+
+ /* u3r_sing_c(): cord/C-string value equivalence.
+ */
+ c3_o
+ u3r_sing_c(const c3_c* a_c,
+ u3_noun b);
+
+ /* u3r_sing_cell():
+ **
+ ** Yes iff `[p q]` and `b` are the same noun.
+ */
+ c3_o
+ u3r_sing_cell(u3_noun p,
+ u3_noun q,
+ u3_noun b);
+
+ /* u3r_sing_mixt():
+ **
+ ** Yes iff `[p q]` and `b` are the same noun.
+ */
+ c3_o
+ u3r_sing_mixt(const c3_c* p_c,
+ u3_noun q,
+ u3_noun b);
+
+ /* u3r_sing_trel():
+ **
+ ** Yes iff `[p q r]` and `b` are the same noun.
+ */
+ c3_o
+ u3r_sing_trel(u3_noun p,
+ u3_noun q,
+ u3_noun r,
+ u3_noun b);
+
+ /* u3r_sing_qual():
+ **
+ ** Yes iff `[p q r s]` and `b` are the same noun.
+ */
+ c3_o
+ u3r_sing_qual(u3_noun p,
+ u3_noun q,
+ u3_noun r,
+ u3_noun s,
+ u3_noun b);
+
+ /* u3r_nord():
+ **
+ ** Return 0, 1 or 2 if `a` is below, equal to, or above `b`.
+ */
+ u3_atom
+ u3r_nord(u3_noun a,
+ u3_noun b);
+
+ /* u3r_mold():
+ **
+ ** Divide `a` as a mold `[b.[p q] c]`.
+ */
+ c3_o
+ u3r_mold(u3_noun a,
+ u3_noun* b,
+ u3_noun* c);
+
+ /* u3r_bite(): retrieve/default $bloq and $step from $bite.
+ */
+ c3_o
+ u3r_bite(u3_noun bite, u3_atom* bloq, u3_atom *step);
+
+ /* u3r_p():
+ **
+ ** & [0] if [a] is of the form [b *c].
+ */
+ c3_o
+ u3r_p(u3_noun a,
+ u3_noun b,
+ u3_noun* c);
+
+ /* u3r_bush():
+ **
+ ** Factor [a] as a bush [b.[p q] c].
+ */
+ c3_o
+ u3r_bush(u3_noun a,
+ u3_noun* b,
+ u3_noun* c);
+
+ /* u3r_pq():
+ **
+ ** & [0] if [a] is of the form [b *c d].
+ */
+ c3_o
+ u3r_pq(u3_noun a,
+ u3_noun b,
+ u3_noun* c,
+ u3_noun* d);
+
+ /* u3r_pqr():
+ **
+ ** & [0] if [a] is of the form [b *c *d *e].
+ */
+ c3_o
+ u3r_pqr(u3_noun a,
+ u3_noun b,
+ u3_noun* c,
+ u3_noun* d,
+ u3_noun* e);
+
+ /* u3r_pqrs():
+ **
+ ** & [0] if [a] is of the form [b *c *d *e *f].
+ */
+ c3_o
+ u3r_pqrs(u3_noun a,
+ u3_noun b,
+ u3_noun* c,
+ u3_noun* d,
+ u3_noun* e,
+ u3_noun* f);
+
+ /* u3r_met():
+ **
+ ** Return the size of (b) in bits, rounded up to
+ ** (1 << a_y).
+ **
+ ** For example, (a_y == 3) returns the size in bytes.
+ ** NB: (a_y) must be < 37.
+ */
+ c3_w
+ u3r_met(c3_y a_y,
+ u3_atom b);
+
+ /* u3r_bit():
+ **
+ ** Return bit (a_w) of (b).
+ */
+ c3_b
+ u3r_bit(c3_w a_w,
+ u3_atom b);
+
+ /* u3r_byte():
+ **
+ ** Return byte (a_w) of (b).
+ */
+ c3_y
+ u3r_byte(c3_w a_w,
+ u3_atom b);
+
+ /* u3r_bytes():
+ **
+ ** Copy bytes (a_w) through (a_w + b_w - 1) from (d) to (c).
+ */
+ void
+ u3r_bytes(c3_w a_w,
+ c3_w b_w,
+ c3_y* c_y,
+ u3_atom d);
+
+ /* u3r_bytes_fit():
+ **
+ ** Copy (len_w) bytes of (a) into (buf_y) if it fits, returning overage.
+ */
+ c3_w
+ u3r_bytes_fit(c3_w len_w,
+ c3_y* buf_y,
+ u3_atom a);
+
+ /* u3r_bytes_alloc():
+ **
+ ** Copy (len_w) bytes starting at (a_w) from (b) into a fresh allocation.
+ */
+ c3_y*
+ u3r_bytes_alloc(c3_w a_w,
+ c3_w len_w,
+ u3_atom b);
+
+ /* u3r_bytes_all():
+ **
+ ** Allocate and return a new byte array with all the bytes of (a),
+ ** storing the length in (len_w).
+ */
+ c3_y*
+ u3r_bytes_all(c3_w* len_w,
+ u3_atom a);
+
+ /* u3r_chop_bits():
+ **
+ ** XOR `wid_d` bits from`src_w` at `bif_g` to `dst_w` at `bif_g`
+ **
+ ** NB: [dst_w] must have space for [bit_g + wid_d] bits
+ */
+ void
+ u3r_chop_bits(c3_g bif_g,
+ c3_d wid_d,
+ c3_g bit_g,
+ c3_w* dst_w,
+ const c3_w* src_w);
+
+ /* u3r_chop_words():
+ **
+ ** Into the bloq space of `met`, from position `fum` for a
+ ** span of `wid`, to position `tou`, XOR from `src_w`
+ ** into `dst_w`.
+ **
+ ** NB: [dst_w] must have space for [tou_w + wid_w] bloqs
+ */
+ void
+ u3r_chop_words(c3_g met_g,
+ c3_w fum_w,
+ c3_w wid_w,
+ c3_w tou_w,
+ c3_w* dst_w,
+ c3_w len_w,
+ const c3_w* src_w);
+
+ /* u3r_chop():
+ **
+ ** Into the bloq space of `met`, from position `fum` for a
+ ** span of `wid`, to position `tou`, XOR from atom `src`
+ ** into `dst_w`.
+ **
+ ** NB: [dst_w] must have space for [tou_w + wid_w] bloqs
+ */
+ void
+ u3r_chop(c3_g met_g,
+ c3_w fum_w,
+ c3_w wid_w,
+ c3_w tou_w,
+ c3_w* dst_w,
+ u3_atom src);
+
+ /* u3r_mp():
+ **
+ ** Copy (b) into (a_mp).
+ */
+ void
+ u3r_mp(mpz_t a_mp,
+ u3_atom b);
+
+ /* u3r_short():
+ **
+ ** Return short (a_w) of (b).
+ */
+ c3_s
+ u3r_short(c3_w a_w,
+ u3_atom b);
+
+ /* u3r_word():
+ **
+ ** Return word (a_w) of (b).
+ */
+ c3_w
+ u3r_word(c3_w a_w,
+ u3_atom b);
+
+
+ /* u3r_word_fit():
+ **
+ ** Fill (out_w) with (a) if it fits, returning success.
+ */
+ c3_t
+ u3r_word_fit(c3_w* out_w,
+ u3_atom a);
+
+ /* u3r_chub():
+ **
+ ** Return double-word (a_w) of (b).
+ */
+ c3_d
+ u3r_chub(c3_w a_w,
+ u3_atom b);
+
+ /* u3r_words():
+ **
+ ** Copy words (a_w) through (a_w + b_w - 1) from (d) to (c).
+ */
+ void
+ u3r_words(c3_w a_w,
+ c3_w b_w,
+ c3_w* c_w,
+ u3_atom d);
+
+ /* u3r_chubs():
+ **
+ ** Copy double-words (a_w) through (a_w + b_w - 1) from (d) to (c).
+ */
+ void
+ u3r_chubs(c3_w a_w,
+ c3_w b_w,
+ c3_d* c_d,
+ u3_atom d);
+
+ /* u3r_safe_byte(): validate and retrieve byte.
+ */
+ c3_o
+ u3r_safe_byte(u3_noun dat, c3_y* out_y);
+
+ /* u3r_safe_word(): validate and retrieve word.
+ */
+ c3_o
+ u3r_safe_word(u3_noun dat, c3_w* out_w);
+
+ /* u3r_safe_chub(): validate and retrieve chub.
+ */
+ c3_o
+ u3r_safe_chub(u3_noun dat, c3_d* out_d);
+
+ /* u3r_string(): `a`, a text atom, as malloced C string.
+ */
+ c3_c*
+ u3r_string(u3_atom a);
+
+ /* u3r_tape(): `a`, a list of bytes, as malloced C string.
+ */
+ c3_y*
+ u3r_tape(u3_noun a);
+
+ /* u3r_skip():
+ **
+ ** Extract a constant from a formula, ignoring
+ ** safe/static hints, doing no computation.
+ */
+ u3_weak
+ u3r_skip(u3_noun fol);
+
+ /* u3r_safe():
+ **
+ ** Returns yes if the formula won't crash
+ ** and has no hints, returning constant result
+ ** if possible
+ */
+ c3_o
+ u3r_safe(u3_noun fol, u3_weak* out);
+
+#endif /* ifndef U3_RETRIEVE_H */