sleela_registry.c
registry/sleela_registry.c · 386 line(s) · c
/*
* registry/sleela_registry.c -- Sleela Registry (C implementation).
*
* Idea System(TM) / Idea(TM). From Author; distributive.
*
* A bounded, deterministic key/value + provenance store. Keys are held in a
* sorted array (so save/review are stable and idempotent). Each key owns a
* small set of named values and, optionally, one provenance record carrying the
* file identity + SHA-256 + originality seal. Pure C.
*/
#include "sleela_registry.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SL_REG_MAX_KEYS 4096
#define SL_REG_MAX_VALUES 16 /* values per key */
#define SL_REG_PATH_CAP 256
#define SL_REG_NAME_CAP 64
#define SL_REG_STR_CAP 256
typedef struct {
char name[SL_REG_NAME_CAP];
sl_reg_kind kind;
char s[SL_REG_STR_CAP];
long i;
int b;
int used;
} RegValue;
typedef struct {
char path[SL_REG_PATH_CAP];
RegValue values[SL_REG_MAX_VALUES];
int nvalues;
int has_prov;
sl_reg_provenance prov;
int used;
} RegKey;
struct sl_registry {
RegKey *keys;
int nkeys;
int cap;
};
/* ---- SHA-256 (FIPS 180-4, self-contained) ----------------------------- */
static uint32_t rotr(uint32_t x, uint32_t n){ return (x>>n)|(x<<(32-n)); }
void sl_reg_sha256_hex(const void *data, size_t len, char *out){
static const uint32_t K[64]={
0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2};
uint32_t h[8]={0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19};
size_t padded=((len+8)/64+1)*64;
unsigned char *m=(unsigned char*)calloc(1,padded);
memcpy(m,data,len); m[len]=0x80;
uint64_t bits=(uint64_t)len*8;
for(int i=0;i<8;++i) m[padded-1-i]=(unsigned char)((bits>>(8*i))&0xff);
for(size_t off=0;off<padded;off+=64){
uint32_t w[64];
for(int i=0;i<16;++i) w[i]=(m[off+i*4]<<24)|(m[off+i*4+1]<<16)|(m[off+i*4+2]<<8)|m[off+i*4+3];
for(int i=16;i<64;++i){ uint32_t s0=rotr(w[i-15],7)^rotr(w[i-15],18)^(w[i-15]>>3); uint32_t s1=rotr(w[i-2],17)^rotr(w[i-2],19)^(w[i-2]>>10); w[i]=w[i-16]+s0+w[i-7]+s1; }
uint32_t a=h[0],b=h[1],c=h[2],d=h[3],e=h[4],f=h[5],g=h[6],hh=h[7];
for(int i=0;i<64;++i){ uint32_t S1=rotr(e,6)^rotr(e,11)^rotr(e,25); uint32_t ch=(e&f)^((~e)&g); uint32_t t1=hh+S1+ch+K[i]+w[i]; uint32_t S0=rotr(a,2)^rotr(a,13)^rotr(a,22); uint32_t maj=(a&b)^(a&c)^(b&c); uint32_t t2=S0+maj; hh=g;g=f;f=e;e=d+t1;d=c;c=b;b=a;a=t1+t2; }
h[0]+=a;h[1]+=b;h[2]+=c;h[3]+=d;h[4]+=e;h[5]+=f;h[6]+=g;h[7]+=hh;
}
free(m);
static const char *hx="0123456789abcdef";
for(int i=0;i<8;++i) for(int j=7;j>=0;--j){ *out++=hx[(h[i]>>(j*4))&0xf]; }
*out='\0';
}
/* ---- seal ------------------------------------------------------------- */
void sl_reg_seal(sl_reg_provenance *p){
if(!p) return;
char buf[17+64+65+128+8];
int n=snprintf(buf,sizeof buf,"%s|%s|%s|%s",p->hex_id,p->version,p->hash,p->author);
if(n<0) n=0;
sl_reg_sha256_hex(buf,(size_t)n,p->seal);
}
int sl_reg_seal_verify(const sl_reg_provenance *p){
if(!p) return 0;
sl_reg_provenance tmp=*p; tmp.seal[0]='\0';
sl_reg_seal(&tmp);
return strncmp(tmp.seal,p->seal,64)==0 ? 1 : 0;
}
/* ---- key store -------------------------------------------------------- */
sl_registry *sl_reg_create(void){
sl_registry *r=(sl_registry*)calloc(1,sizeof(*r));
if(!r) return NULL;
r->cap=SL_REG_MAX_KEYS;
r->keys=(RegKey*)calloc((size_t)r->cap,sizeof(RegKey));
if(!r->keys){ free(r); return NULL; }
return r;
}
void sl_reg_destroy(sl_registry *r){ if(r){ free(r->keys); free(r); } }
static RegKey *find_key(const sl_registry *r,const char *path){
for(int i=0;i<r->nkeys;++i) if(r->keys[i].used && strcmp(r->keys[i].path,path)==0) return (RegKey*)&r->keys[i];
return NULL;
}
static int key_cmp(const void*a,const void*b){ return strcmp(((const RegKey*)a)->path,((const RegKey*)b)->path); }
static RegKey *ensure_key(sl_registry *r,const char *path){
RegKey *k=find_key(r,path);
if(k) return k;
if(r->nkeys>=r->cap) return NULL;
k=&r->keys[r->nkeys++];
memset(k,0,sizeof(*k));
strncpy(k->path,path,SL_REG_PATH_CAP-1);
k->used=1;
qsort(r->keys,(size_t)r->nkeys,sizeof(RegKey),key_cmp);
return find_key(r,path);
}
sl_reg_status sl_reg_key_create(sl_registry *r,const char *path){
if(!r||!path) return SL_REG_INVALID;
/* make parents: A, A/B, A/B/C */
char buf[SL_REG_PATH_CAP]; strncpy(buf,path,sizeof buf-1); buf[sizeof buf-1]='\0';
char acc[SL_REG_PATH_CAP]=""; char *tok=strtok(buf,"/");
while(tok){ if(acc[0]) strncat(acc,"/",sizeof acc-strlen(acc)-1); strncat(acc,tok,sizeof acc-strlen(acc)-1);
if(!ensure_key(r,acc)) return SL_REG_LIMIT; tok=strtok(NULL,"/"); }
if(!path[0]) ensure_key(r,"");
return SL_REG_OK;
}
int sl_reg_key_exists(const sl_registry *r,const char *path){ return (r&&path&&find_key(r,path))?1:0; }
int sl_reg_key_children(const sl_registry *r,const char *path,char **names,int max,size_t name_cap){
if(!r||!path||!names) return 0;
size_t plen=strlen(path);
int count=0;
for(int i=0;i<r->nkeys&&count<max;++i){
const char *kp=r->keys[i].path;
if(!r->keys[i].used) continue;
if(plen>0){ if(strncmp(kp,path,plen)!=0||kp[plen]!='/') continue; kp+=plen+1; }
if(!*kp) continue;
if(strchr(kp,'/')) continue; /* direct child only */
strncpy(names[count],kp,name_cap-1); names[count][name_cap-1]='\0'; count++;
}
return count;
}
/* ---- values ----------------------------------------------------------- */
static RegValue *find_val(RegKey *k,const char *name){
for(int i=0;i<k->nvalues;++i) if(k->values[i].used&&strcmp(k->values[i].name,name)==0) return &k->values[i];
return NULL;
}
static RegValue *ensure_val(RegKey *k,const char *name){
RegValue *v=find_val(k,name); if(v) return v;
if(k->nvalues>=SL_REG_MAX_VALUES) return NULL;
v=&k->values[k->nvalues++]; memset(v,0,sizeof(*v));
strncpy(v->name,name,SL_REG_NAME_CAP-1); v->used=1; return v;
}
sl_reg_status sl_reg_set_string(sl_registry *r,const char *path,const char *name,const char *value){
if(!r||!path||!name||!value) return SL_REG_INVALID;
sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT;
RegValue *v=ensure_val(k,name); if(!v) return SL_REG_LIMIT;
v->kind=SL_REG_STRING; strncpy(v->s,value,SL_REG_STR_CAP-1); v->s[SL_REG_STR_CAP-1]='\0';
return SL_REG_OK;
}
sl_reg_status sl_reg_set_int(sl_registry *r,const char *path,const char *name,long value){
if(!r||!path||!name) return SL_REG_INVALID;
sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT;
RegValue *v=ensure_val(k,name); if(!v) return SL_REG_LIMIT; v->kind=SL_REG_INT; v->i=value; return SL_REG_OK;
}
sl_reg_status sl_reg_set_bool(sl_registry *r,const char *path,const char *name,int value){
if(!r||!path||!name) return SL_REG_INVALID;
sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT;
RegValue *v=ensure_val(k,name); if(!v) return SL_REG_LIMIT; v->kind=SL_REG_BOOL; v->b=value?1:0; return SL_REG_OK;
}
sl_reg_status sl_reg_get_string(const sl_registry *r,const char *path,const char *name,char *buf,size_t cap){
if(!r||!path||!name||!buf) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND;
RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; if(v->kind!=SL_REG_STRING) return SL_REG_INVALID;
strncpy(buf,v->s,cap-1); buf[cap-1]='\0'; return SL_REG_OK;
}
sl_reg_status sl_reg_get_int(const sl_registry *r,const char *path,const char *name,long *out){
if(!r||!path||!name||!out) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND;
RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; if(v->kind!=SL_REG_INT) return SL_REG_INVALID; *out=v->i; return SL_REG_OK;
}
sl_reg_status sl_reg_get_bool(const sl_registry *r,const char *path,const char *name,int *out){
if(!r||!path||!name||!out) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND;
RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; if(v->kind!=SL_REG_BOOL) return SL_REG_INVALID; *out=v->b; return SL_REG_OK;
}
sl_reg_status sl_reg_value_kind(const sl_registry *r,const char *path,const char *name,sl_reg_kind *kind){
if(!r||!path||!name||!kind) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k) return SL_REG_NOT_FOUND;
RegValue *v=find_val(k,name); if(!v) return SL_REG_NOT_FOUND; *kind=v->kind; return SL_REG_OK;
}
sl_reg_status sl_reg_feature_set(sl_registry *r,const char *name,int enabled){
char p[SL_REG_PATH_CAP]; snprintf(p,sizeof p,"Features"); (void)name; return sl_reg_set_bool(r,p,name,enabled);
}
int sl_reg_feature_enabled(const sl_registry *r,const char *name){
int out=0; if(sl_reg_get_bool(r,"Features",name,&out)==SL_REG_OK) return out; return 0;
}
/* ---- provenance ------------------------------------------------------- */
sl_reg_status sl_reg_provenance_set(sl_registry *r,const char *path,const sl_reg_provenance *p){
if(!r||!path||!p) return SL_REG_INVALID;
sl_reg_key_create(r,path); RegKey *k=find_key(r,path); if(!k) return SL_REG_LIMIT;
k->prov=*p;
if(k->prov.seal[0]=='\0') sl_reg_seal(&k->prov);
k->has_prov=1; return SL_REG_OK;
}
sl_reg_status sl_reg_provenance_get(const sl_registry *r,const char *path,sl_reg_provenance *out){
if(!r||!path||!out) return SL_REG_INVALID; RegKey *k=find_key(r,path); if(!k||!k->has_prov) return SL_REG_NOT_FOUND;
*out=k->prov; return SL_REG_OK;
}
/* ---- seed ------------------------------------------------------------- */
sl_reg_status sl_reg_seed_defaults(sl_registry *r){
if(!r) return SL_REG_INVALID;
sl_reg_key_create(r,"System");
sl_reg_set_string(r,"System","name","Idea System(TM) / SLeeLa");
sl_reg_set_string(r,"System","registryVersion",SLEELA_REGISTRY_VERSION);
sl_reg_key_create(r,"System/VM");
sl_reg_set_string(r,"System/VM","default","native");
sl_reg_key_create(r,"Settings");
sl_reg_set_int(r,"Settings","memoryLimitMiB",2048);
sl_reg_set_int(r,"Settings","threadCap",128);
sl_reg_set_string(r,"Settings","verbosity","normal");
sl_reg_key_create(r,"Features");
sl_reg_set_bool(r,"Features","modium",1);
sl_reg_set_bool(r,"Features","vmSelect",1);
sl_reg_set_bool(r,"Features","premiumVms",1);
sl_reg_key_create(r,"Artifacts");
/* Math: precision-norm defaults + the pi catalog locators. Mirrors the
* SLeeLa model in lib/registry/SLRegistry.sleela seedDefaults(). The large
* pi value is referenced by LOCATOR only (per REGISTRY-3.0-MODIUM.md the
* registry never stores the bytes); Modium resolves the path to the
* installed file and loads it at subsystem startup. */
sl_reg_key_create(r,"Math");
sl_reg_set_int(r,"Math","irrationalDigitCarry",2048);
sl_reg_set_int(r,"Math","repeatingDigitCarry",58);
sl_reg_set_int(r,"Math","financeCarry",1023);
sl_reg_set_int(r,"Math","piReferenceDigits",2048);
sl_reg_set_string(r,"Math","piReference",
"3.141592653589793238462643383279502884197169399375105820974944");
sl_reg_set_int(r,"Math","piReferenceLargeDigits",100000000);
sl_reg_set_string(r,"Math","piReferenceLargePath","pi-generator/pi.100000000.digits");
return SL_REG_OK;
}
/* ---- persistence (.sleelareg text format) ----------------------------- */
sl_reg_status sl_reg_save(const sl_registry *r,const char *path){
if(!r||!path) return SL_REG_INVALID;
FILE *f=fopen(path,"wb"); if(!f) return SL_REG_INVALID;
fprintf(f,"%s %d\n",SLEELA_REGISTRY_MAGIC,SLEELA_REGISTRY_FORMAT);
for(int i=0;i<r->nkeys;++i){ const RegKey *k=&r->keys[i]; if(!k->used) continue;
fprintf(f,"[%s]\n",k->path);
for(int j=0;j<k->nvalues;++j){ const RegValue *v=&k->values[j]; if(!v->used) continue;
if(v->kind==SL_REG_STRING) fprintf(f,"= s %s %s\n",v->name,v->s);
else if(v->kind==SL_REG_INT) fprintf(f,"= i %s %ld\n",v->name,v->i);
else fprintf(f,"= b %s %d\n",v->name,v->b);
}
if(k->has_prov){ const sl_reg_provenance *p=&k->prov;
fprintf(f,"@ %s | %s | %s | %s | %s | %s | %s\n",
p->name,p->date,p->author,p->version,p->hex_id,p->hash,p->seal);
}
}
fclose(f); return SL_REG_OK;
}
sl_reg_status sl_reg_load(sl_registry *r,const char *path){
if(!r||!path) return SL_REG_INVALID;
FILE *f=fopen(path,"rb"); if(!f) return SL_REG_NOT_FOUND;
char line[1024]; char cur[SL_REG_PATH_CAP]="";
if(!fgets(line,sizeof line,f)){ fclose(f); return SL_REG_MALFORMED; }
if(strncmp(line,SLEELA_REGISTRY_MAGIC,5)!=0){ fclose(f); return SL_REG_MALFORMED; }
r->nkeys=0;
while(fgets(line,sizeof line,f)){
size_t L=strlen(line); while(L&&(line[L-1]=='\n'||line[L-1]=='\r')) line[--L]='\0';
if(line[0]=='['){ char *e=strchr(line,']'); if(e){ *e='\0'; strncpy(cur,line+1,sizeof cur-1); cur[sizeof cur-1]='\0'; sl_reg_key_create(r,cur); } }
else if(line[0]=='='&&line[2]){ char t=line[2]; char nm[SL_REG_NAME_CAP]; char rest[SL_REG_STR_CAP];
if(sscanf(line+4,"%63s %255[^\n]",nm,rest)>=1){
if(t=='s') sl_reg_set_string(r,cur,nm,rest);
else if(t=='i') sl_reg_set_int(r,cur,nm,strtol(rest,NULL,10));
else if(t=='b') sl_reg_set_bool(r,cur,nm,atoi(rest));
}
}
else if(line[0]=='@'){ sl_reg_provenance p; memset(&p,0,sizeof p);
/* name | date | author | version | hexid | hash | seal */
sscanf(line+2,"%255[^|] | %31[^|] | %127[^|] | %63[^|] | %16[^|] | %64[^|] | %64[^\n]",
p.name,p.date,p.author,p.version,p.hex_id,p.hash,p.seal);
/* trim trailing spaces from fields */
for(char*s=p.name+strlen(p.name)-1;s>=p.name&&*s==' ';--s)*s='\0';
for(char*s=p.hash+strlen(p.hash)-1;s>=p.hash&&*s==' ';--s)*s='\0';
for(char*s=p.seal+strlen(p.seal)-1;s>=p.seal&&*s==' ';--s)*s='\0';
sl_reg_provenance_set(r,cur,&p);
}
}
fclose(f); return SL_REG_OK;
}
/* ---- SQL export ------------------------------------------------------- */
static void sql_esc(const char*s,char*out,size_t cap){ size_t j=0; for(size_t i=0;s&&s[i]&&j+2<cap;++i){ if(s[i]=='\''||s[i]=='\\'){ out[j++]='\\'; } out[j++]=s[i]; } out[j]='\0'; }
sl_reg_status sl_reg_export_sql(const sl_registry *r,const char *path){
if(!r||!path) return SL_REG_INVALID;
FILE *f=fopen(path,"wb"); if(!f) return SL_REG_INVALID;
fprintf(f,"-- sleela registry SQL export. Idea System(TM) / Idea(TM). From Author; distributive.\n");
fprintf(f,"-- Portable MySQL/MariaDB: load with `mysql <db> < this_file`. Deterministic (sorted).\n\n");
fprintf(f,"CREATE TABLE IF NOT EXISTS registry_entries (\n"
" id INT AUTO_INCREMENT PRIMARY KEY,\n"
" key_path VARCHAR(256) NOT NULL,\n"
" name VARCHAR(64) NOT NULL,\n"
" kind VARCHAR(8) NOT NULL,\n"
" value TEXT NOT NULL,\n"
" UNIQUE KEY uq_entry (key_path, name)\n);\n\n");
fprintf(f,"CREATE TABLE IF NOT EXISTS registry_provenance (\n"
" id INT AUTO_INCREMENT PRIMARY KEY,\n"
" key_path VARCHAR(256) NOT NULL,\n"
" file VARCHAR(256) NOT NULL, date VARCHAR(32) NOT NULL,\n"
" author VARCHAR(128) NOT NULL, version VARCHAR(64) NOT NULL,\n"
" hex_id CHAR(16) NOT NULL, hash CHAR(64) NOT NULL, seal CHAR(64) NOT NULL,\n"
" UNIQUE KEY uq_prov (key_path)\n);\n\n");
char eb[1024];
for(int i=0;i<r->nkeys;++i){ const RegKey *k=&r->keys[i]; if(!k->used) continue;
for(int j=0;j<k->nvalues;++j){ const RegValue *v=&k->values[j]; if(!v->used) continue;
const char *kind = v->kind==SL_REG_STRING?"string":(v->kind==SL_REG_INT?"int":"bool");
char val[SL_REG_STR_CAP+8];
if(v->kind==SL_REG_STRING) sql_esc(v->s,val,sizeof val);
else if(v->kind==SL_REG_INT) snprintf(val,sizeof val,"%ld",v->i);
else snprintf(val,sizeof val,"%d",v->b);
char ekp[520]; sql_esc(k->path,ekp,sizeof ekp);
fprintf(f,"INSERT INTO registry_entries (key_path,name,kind,value) VALUES ('%s','%s','%s','%s');\n",
ekp,v->name,kind,val);
}
if(k->has_prov){ const sl_reg_provenance *p=&k->prov; char ekp[520]; sql_esc(k->path,ekp,sizeof ekp);
char ef[520],ea[260]; sql_esc(p->name,ef,sizeof ef); sql_esc(p->author,ea,sizeof ea);
fprintf(f,"INSERT INTO registry_provenance (key_path,file,date,author,version,hex_id,hash,seal) VALUES "
"('%s','%s','%s','%s','%s','%s','%s','%s');\n",
ekp,ef,p->date,ea,p->version,p->hex_id,p->hash,p->seal);
}
}
(void)eb;
fclose(f); return SL_REG_OK;
}
/* ---- review ----------------------------------------------------------- */
long sl_reg_review(const sl_registry *r,const char *path,char *buf,size_t cap){
if(!r||!buf||cap==0) return SL_REG_INVALID;
char *p=buf; char *end=buf+cap; int w;
size_t plen=path?strlen(path):0;
w=snprintf(p,(size_t)(end-p),"Sleela Registry %s (keys=%d values=%d provenance=%d)\n",
SLEELA_REGISTRY_VERSION,sl_reg_key_count(r),sl_reg_value_count(r),sl_reg_provenance_count(r));
if(w>0&&p+w<end) p+=w;
for(int i=0;i<r->nkeys&&p<end;++i){ const RegKey *k=&r->keys[i]; if(!k->used) continue;
if(path&&plen>0&&!(strcmp(k->path,path)==0||(strncmp(k->path,path,plen)==0&&k->path[plen]=='/'))) continue;
w=snprintf(p,(size_t)(end-p),"[%s]\n",k->path[0]?k->path:"(root)"); if(w>0&&p+w<end)p+=w;
for(int j=0;j<k->nvalues&&p<end;++j){ const RegValue *v=&k->values[j]; if(!v->used) continue;
if(v->kind==SL_REG_STRING) w=snprintf(p,(size_t)(end-p)," %s = \"%s\"\n",v->name,v->s);
else if(v->kind==SL_REG_INT) w=snprintf(p,(size_t)(end-p)," %s = %ld\n",v->name,v->i);
else w=snprintf(p,(size_t)(end-p)," %s = %s\n",v->name,v->b?"true":"false");
if(w>0&&p+w<end)p+=w;
}
if(k->has_prov&&p<end){ const sl_reg_provenance *pr=&k->prov;
w=snprintf(p,(size_t)(end-p),
" <provenance> file=%s author=%s version=%s hexid=%s\n"
" hash=%s seal=%s [%s]\n",
pr->name,pr->author,pr->version,pr->hex_id,pr->hash,pr->seal,
sl_reg_seal_verify(pr)?"SEALED":"BROKEN");
if(w>0&&p+w<end)p+=w;
}
}
return (long)(p-buf);
}
int sl_reg_key_count(const sl_registry *r){ int c=0; for(int i=0;i<r->nkeys;++i) if(r->keys[i].used)c++; return c; }
int sl_reg_value_count(const sl_registry *r){ int c=0; for(int i=0;i<r->nkeys;++i){ if(!r->keys[i].used)continue; for(int j=0;j<r->keys[i].nvalues;++j) if(r->keys[i].values[j].used)c++; } return c; }
int sl_reg_provenance_count(const sl_registry *r){ int c=0; for(int i=0;i<r->nkeys;++i) if(r->keys[i].used&&r->keys[i].has_prov)c++; return c; }
const char *sl_reg_status_name(sl_reg_status s){
switch(s){
case SL_REG_OK: return "OK"; case SL_REG_INVALID: return "INVALID";
case SL_REG_NOT_FOUND: return "NOT_FOUND"; case SL_REG_EXISTS: return "EXISTS";
case SL_REG_LIMIT: return "LIMIT"; case SL_REG_MALFORMED: return "MALFORMED";
case SL_REG_SEAL_BROKEN: return "SEAL_BROKEN"; default: return "UNKNOWN";
}
}