nntrac

nntrac.c (43227B)

---

 /*
  * no-nonsense TRAC programming language implementation (T64 standard)
  * 
  * Build with: cc [-static] -std=c99 -Os -s nntrac.c -o nntrac
  *
  * see README.md for details
  *
  * Created by Luxferre in 2023, released into public domain
  */
 
 #define POSIX_SOURCE
 #define POSIX_C_SOURCE 1
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 
 #define uint unsigned int
 #define uchar unsigned char
 #ifndef NNT_SHARP
 #define NNT_SHARP '#' /* can be redefined to : or other unused character */
 #endif
 #ifndef NNT_SYMNAMELEN
 #define NNT_SYMNAMELEN 32 /* max symbol name length, including null */
 #endif
 
 #ifndef strrev
 char *strrev(char *str) {
   char *p1, *p2;
   if(!str || !*str) return str;
   for(p1=str,p2=str+strlen(str)-1;p2>p1;++p1,--p2) {
     *p1 ^= *p2; *p2 ^= *p1; *p1 ^= *p2;
   }
   return str;
 }
 #endif
 
 enum NNT_MARKERS { /* various markers: 248 to 255 never occur in UTF-8 */
   NNT_AFST=-8,  /* active function start */
   NNT_NFST,     /* neutral function start */
   NNT_EOF,      /* end of function */
   NNT_ADEL,     /* argument delimiter */
   NNT_SEGGAP    /* segment gap character */
 };
 enum NNT_MODES {NNT_NORMAL=1, NNT_LEGACY, NNT_SECURE}; /* operation modes */
 static const char NNT_ADEL_S[2] = {NNT_ADEL, 0};
 static uchar nnt_meta = '\''; /* apostrophe by default */
 
 /* combined active + neutral string buffer and evaluation result buffer */
 static char *nnt_prog, *nnt_res, nnt_mode = NNT_NORMAL, nnt_mlock = 0;
 /* scanning pointers and buffer lengths */
 static int nnt_ascan, nnt_alen, nnt_flen, nnt_reslen, nnt_trace = 0;
 
 /* string to number */
 long long snum(char *str) { /* strtoll wrapper */
   char *endptr;
   return strtoll(str, &endptr, 0);
 }
 
 /* number to string */
 char *n2s(long long num, char *s, int *slen) {
   *slen = snprintf(NULL, 0, "%lld", num) + 1;
   s = realloc(s, *slen);
   memset(s, 0, *slen); /* fill it with zeroes*/
   snprintf(s, *slen, "%lld", num);
   s = realloc(s, (*slen) = strlen(s));
   return s;
 }
 
 /* primitive function definition */
 
 typedef struct nnt_primitive_t {
   char name[NNT_SYMNAMELEN];       /* primitive function name */
   /* registered function pointer */
   char* (*handler)(char *arglist, char *res, int *reslen);
 } nnt_primitive;
 
 static nnt_primitive *nnt_primitives; /* primitives table */
 static uint nnt_primitive_len = 0; /* primitives table size */
 
 /* find a primitive function index by name, -1 if not found */
 int nnt_findprimitive(const char *name) {
   int i;
   for(i=0;i<nnt_primitive_len;i++)
     if(strncmp(nnt_primitives[i].name, name, NNT_SYMNAMELEN) == 0)
       return i; /* found */
   return -1;  /* nothing found */
 }
 
 /* register a primitive function, overwrite if already exists */
 void nnt_regprimitive(const char *name, void *fptr) {
   int pindex = nnt_findprimitive(name);
   nnt_primitive newprim; /* create a new primitive template */
   strncpy(newprim.name, name, NNT_SYMNAMELEN); /* fill the name */
   newprim.handler = fptr; /* fill the handler pointer */
   if(pindex == -1) { /* create a new table entry */
     nnt_primitive_len++;
     nnt_primitives = realloc(nnt_primitives,
                               nnt_primitive_len * sizeof(nnt_primitive));
     nnt_primitives[nnt_primitive_len - 1] = newprim; 
   }
   else nnt_primitives[pindex] = newprim; /* replace the entry */
 }
 
 /* forms definition */
 
 typedef struct nnt_form_t {
   char name[NNT_SYMNAMELEN]; /* form (var/func) name */
   char *value;       /* (reallocatable) value pointer (null-terminated) */
   uint len;          /* form value length */
   int fptr;          /* form character pointer */
 } nnt_form;
 
 static nnt_form *nnt_forms; /* forms table */
 static uint nnt_forms_len = 0; /* forms table size */
 
 /* find a form index by name, -1 if not found */
 int nnt_findform(char *name) {
   int i;
   for(i=0;i<nnt_forms_len;i++)
     if(strncmp(nnt_forms[i].name, name, NNT_SYMNAMELEN) == 0)
       return i; /* found */
   return -1;  /* nothing found */
 }
 
 /* find a free form among previously deleted entries */
 int nnt_findfreeform() {
   int i;
   for(i=0;i<nnt_forms_len;i++)
     if(nnt_forms[i].name[0] == NNT_EOF) return i; /* found */
   return -1;  /* nothing found */
 }
 
 /* assign a value to a form, creating it if doesn't exist */
 void nnt_assignform(char *name, char *value, uint len, int ptr) {
   int findex = nnt_findform(name);
   if(findex < 0) findex = nnt_findfreeform(); /* search among deleted */
   if(findex > -1) { /* existing form: just update the entry */
     strncpy(nnt_forms[findex].name, name, NNT_SYMNAMELEN);
     nnt_forms[findex].value = realloc(nnt_forms[findex].value, len);
     memcpy(nnt_forms[findex].value, value, len);
     nnt_forms[findex].len = len; /* also update the length */
     nnt_forms[findex].fptr = ptr; /* reset the pointer */
   } else { /* create a new form and update the table */
     nnt_form newform;
     strncpy(newform.name, name, NNT_SYMNAMELEN); /* fill the name */
     newform.value = calloc(len, 1); /* allocate the space */
     memcpy(newform.value, value, len); /* populate the value */
     newform.len = len; /* populate the length */
     newform.fptr = ptr;  /* init the pointer */
     nnt_forms_len++;
     nnt_forms = realloc(nnt_forms, nnt_forms_len * sizeof(nnt_form));
     nnt_forms[nnt_forms_len - 1] = newform;
   }
 }
 
 /* delete a form by its name */
 /* doesn't fully delete the structure, just marks it as free to use */
 void nnt_delform(char *name) {
   int findex = nnt_findform(name);
   if(findex > -1) {
     nnt_forms[findex].value = realloc(nnt_forms[findex].value, 0);
     nnt_forms[findex].len = 0;
     nnt_forms[findex].fptr = 0;
     memset(nnt_forms[findex].name, 0, NNT_SYMNAMELEN);
     /* null name is a valid form name in TRAC, so we use a marker char */
     nnt_forms[findex].name[0] = NNT_EOF;
   }
 }
 
 /* form serialization/deserialization using netstrings */
 
 /* serialize the form and populate the buffer and length */
 char* nnt_serializeform(nnt_form *form, char *buf, int *len) {
   *len = NNT_SYMNAMELEN + form->len + sizeof(int);
   int lbl = snprintf(NULL, 0, "%d:", *len); /* length buffer length */
   char *lenbuf = calloc(lbl + 1, 1); 
   snprintf(lenbuf, lbl+1, "%d:", *len); /* fill in length buffer */
   *len += lbl;
   buf = realloc(buf, *len);
   memset(buf, 0, *len); /* zero out the buffer */
   memcpy(buf, lenbuf, lbl); /* fill the length buffer */
   memcpy(buf + lbl, form->name, NNT_SYMNAMELEN); /* fill name */
   memcpy(buf + lbl + NNT_SYMNAMELEN, &(form->fptr), sizeof(int)); /* fill fptr */
   /* fill value */
   memcpy(buf + lbl + NNT_SYMNAMELEN + sizeof(int), form->value, form->len);
   buf[(*len) - 1] = ','; /* trailing comma */
   free(lenbuf); return buf;
 }
 
 /* deserialize the form given the netstring buffer
 (push it into the form storage using nnt_assignform) */
 int nnt_deserializeform(char *buf) {
   char lenbuf[11] = {0};
   int i, rdlen, fullen, rdptr, fid;
   for(i=0;buf[i]!=':' && i<11;i++) lenbuf[i] = buf[i];
   rdlen = snum(lenbuf); /* practical read length */
   fullen = rdlen + strlen(lenbuf);
   if(buf[fullen] != ',') return -1; /* invalid netstring detected */
   memcpy(&rdptr, &buf[i+1+NNT_SYMNAMELEN], sizeof(int)); /* fetch pointer */
   /* name is at i + 1, value is NNT_SYMNAMELEN + sizeof(int) away */
   nnt_assignform(&buf[i+1], &buf[i+1+NNT_SYMNAMELEN+sizeof(int)],
     rdlen-NNT_SYMNAMELEN-sizeof(int)-1, rdptr);
   /* return the total length of processed data */
   return fullen;
 }
 
 /* parser logic */
 
 /* find the matching character */
 int nnt_findmatch(char *str, uint len, int curpos, 
       uchar c1, uchar c2, int dir) {
   int balance = 0, xpos = curpos;
   if(xpos >= len) return -1;
   for(;xpos >=0 && xpos < len ;xpos += dir) {
     if(str[xpos] == c1) balance++;
     if(str[xpos] == c2) balance--;
     if(!balance) break;
   }
   return (xpos >= 0 && xpos < len) ? xpos : -1;
 }
 
 /* delete len chars from buf at pos, return new buf length */
 int nnt_delchars(char *buf, int buflen, int pos, int len) {
   if(len < 1) len = 1; /* safeguard */
   if(pos < 0) pos = 0; /* safeguard */
   memmove(&buf[pos], &buf[pos+len], buflen - pos - len);
   return buflen - len;
 }
 
 /* delete a single character under the pos in the active buffer */
 int nnt_delchar(int pos) {
   nnt_flen = nnt_delchars(nnt_prog, nnt_flen, pos, 1);
   nnt_prog[nnt_flen] = 0;
   nnt_alen = nnt_flen - nnt_ascan; /* update active length */
   return nnt_flen;
 }
 
 /* insert len chars into buffer dest of length dlen from buffer src at pos */
 /* it reallocs dest, updates dlen and returns the resulting dest pointer */
 char* nnt_inschars(char *dest, int *dlen, char *src, int len, int pos) {
   *dlen += len; /* increase the length */
   dest = realloc(dest, *dlen); /* reallocate the buffer */
   memmove(&dest[pos+len], &dest[pos], (*dlen)-pos-len); /* free up the space */
   memmove(&dest[pos], src, len); /* copy the source */
   return dest;
 }
 
 /* replace all occurrences of from with to in str (all null-terminated) */
 /* returns the new str pointer (str must be dynamically allocated before) */
 char *nnt_replace(char *str, char *from, char *to) {
   int len = strlen(str), fromlen = strlen(from), tolen = strlen(to), i;
   char *ptr = str;
   while((ptr = strstr(ptr, from)) != NULL) { /* find the occurrence */
     len = nnt_delchars(str, len, (int) (ptr - str), fromlen); /* delete */
     str = nnt_inschars(str, &len, to, tolen, (int) (ptr - str)); /* add */
     ptr += tolen; /* move ptr */
   }
   str[len] = 0; /* ensure null termination in the result */
   return str;
 }
 
 /* cl primitive: call string (form) */
 char* prim_cl(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name, *seg, snum = 0;
   char idstr[3] = {NNT_SEGGAP, 0, 0}; /* update idstr[1] then */
   int fid = -1;
   /* skip the first one */
   name = strtok(NULL, NNT_ADEL_S); /* get the name */
   if(name != NULL && (fid = nnt_findform(name)) > -1) {
     /* populate the result */
     *reslen = nnt_forms[fid].len;
     res = realloc(res, *reslen);
     memcpy(res, nnt_forms[fid].value, *reslen);  
     do { /* receive the segment ids */
       seg = strtok(NULL, NNT_ADEL_S);
       if(seg != NULL) {
         snum++; /* we start from 1 to avoid null bytes */
         idstr[1] = snum; /* update the segmentid byte */
         res = nnt_replace(res, idstr, seg);
         *reslen = strlen(res) + 1;
       }
     } while(seg != NULL);
   }
   return res;
 }
 
 /* evaluate a TRAC function based on the neutral string
    storing the results into nnt_res and nnt_reslen */
 void nnt_evalfunc(int startptr) {
   char *arglist, *primname, *arg;
   int i, l=0, primindex;
   for(i=startptr;nnt_prog[i]!=NNT_EOF;i++,l++);
   arglist = calloc(l, 1);
   for(i=0;i<l;i++) arglist[i] = nnt_prog[startptr + i];
   /* now we have NNT_ADEL-delimited argument list to pass */
   nnt_reslen = 0; /* null value is by default */
   primname = strtok(arglist, NNT_ADEL_S); /* get primitive name */
   primindex = nnt_findprimitive(primname);
   if(primindex > -1) { /* primitive found */
     if(nnt_trace) { /* trace mode */
       fprintf(stderr, "[nntrace] (%s", primname);
       while((arg = strtok(NULL, NNT_ADEL_S)) != NULL)
         fprintf(stderr, ",%s", arg);
       fprintf(stderr, ")");
     }
     for(i=0;i<l;i++) arglist[i] = nnt_prog[startptr + i]; /* restore */
     nnt_res = (*(nnt_primitives[primindex].handler))(arglist, nnt_res, &nnt_reslen);
   }
   /* now we have some core-level primitives */
   else if(strncmp(primname, "hl", 3) == 0) nnt_reslen = -1; /* halt */
   else if(strncmp(primname, "tn", 3) == 0) nnt_trace = 1; /* trace on */
   else if(strncmp(primname, "tf", 3) == 0) nnt_trace = 0; /* trace off */
   else { /* not found, run the default call logic */
     if(nnt_trace) { /* trace mode */
       fprintf(stderr, "[nntrace] (cl,%s",primname);
       while((arg = strtok(NULL, NNT_ADEL_S)) != NULL)
         fprintf(stderr, ",%s", arg);
       fprintf(stderr, ")");
     }
     /* expand the arglist */
     arglist = realloc(arglist, l + 2);
     /* insert a dummy char and the argument delimiter at the start */
     arglist[0] = '0'; arglist[1] = NNT_ADEL;
     for(i=0;i<l;i++) arglist[i+2] = nnt_prog[startptr + i]; /* restore */
     nnt_res = prim_cl(arglist, nnt_res, &nnt_reslen);
   }
   if(nnt_trace) { /* trace mode */
     if(nnt_reslen)
       fprintf(stderr, " => %*.*s\r\n", nnt_reslen, nnt_reslen, nnt_res);
     else fprintf(stderr, " => null\r\n"); 
   }
   if(arglist) free(arglist);
 }
 
 /* main TRAC processing algorithm */ 
 void nnt_proc(char *prog, uint len) {
   nnt_res = malloc(nnt_reslen = 0); /* init the result buffer */
   nnt_prog = calloc(len+1, 1);  /* init the neutral+active string buffer */
   /* load the entire program into the active string */
   memcpy(nnt_prog, prog, len);
   uchar cc; /* currently processed character */
   int bp, rl, j; /* position buffers for various needs */
   nnt_ascan = 0; /* init the pointer and NS length */
   nnt_alen = nnt_flen = len; /* init active length with the full length */
   while(nnt_alen >= 0) { /* processing loop start */
     switch((cc = nnt_prog[nnt_ascan])) { /* rule 1 */
       case '(': /* rule 2 */
         bp = nnt_findmatch(nnt_prog, nnt_flen, nnt_ascan, '(', ')', 1);
         if(bp > -1) { /* copy the entire region into the neutral string */
           rl = bp - nnt_ascan; /* nested region length */
           nnt_delchar(nnt_ascan); /* delete this paren */
           nnt_ascan += rl - 1; /* increment active pointer */
           nnt_delchar(nnt_ascan); /* delete matching paren */
         }
         break;
       case '\r': case '\n': case '\t': /* rule 3 */
         nnt_delchar(nnt_ascan);
         break;
       case ',': /* rule 4 */
         nnt_prog[nnt_ascan++] = NNT_ADEL; /* argument delimiter */ 
         break;
       case NNT_SHARP: /* rules 5 to 7 */
         switch(nnt_prog[nnt_ascan+1]) {
           case '(': /* rule 5 - active function start */
             nnt_delchar(nnt_ascan); /* remove # character */
             nnt_prog[nnt_ascan++] = NNT_AFST;
             break;
           case NNT_SHARP: /* rule 6 */
             if(nnt_prog[nnt_ascan+2] == '(') { /* neutral function start */
               nnt_delchar(nnt_ascan); /* remove # character */
               nnt_delchar(nnt_ascan); /* remove another # character */
               nnt_prog[nnt_ascan++] = NNT_NFST;
             } else nnt_ascan++; /* rule 7 */
             break;
           default: nnt_ascan++; /* rule 7 */
         }
         break;
       case ')': /* rule 8 */
         nnt_prog[nnt_ascan] = NNT_EOF;
         for(bp = nnt_ascan-1;bp>0;bp--) /* find function start */
           if(nnt_prog[bp] == NNT_AFST || nnt_prog[bp] == NNT_NFST) break;
         /* evaluate the function: the result is stored into nnt_res,
            its length into nnt_reslen */
         nnt_evalfunc(bp + 1); /* skip function start marker */
         if(nnt_reslen > 0) {
           nnt_prog = nnt_inschars(nnt_prog, &nnt_flen,
                                   nnt_res, nnt_reslen, nnt_ascan + 1);
           if(nnt_prog[bp] == NNT_AFST) { /* rule 11 */
             nnt_flen = nnt_delchars(nnt_prog, nnt_flen, bp, nnt_ascan - bp + 1);
             nnt_ascan = bp;
           } else if(nnt_prog[bp] == NNT_NFST) { /* rule 12 */
             nnt_flen = nnt_delchars(nnt_prog, nnt_flen, bp, nnt_ascan - bp + 1);
             nnt_ascan = bp + nnt_reslen;
           }
         } else if(nnt_reslen == 0) { /* rule 10 */
           nnt_flen = nnt_delchars(nnt_prog, nnt_flen, bp, nnt_ascan - bp + 1);
           nnt_ascan = bp;    
         } else nnt_ascan = nnt_flen + 1; /* negative reslen causes the halt */ 
         break;
       default: nnt_ascan++; /* rule 9 */
     }    
     nnt_alen = nnt_flen - nnt_ascan; /* update the length on every step */
     nnt_prog[nnt_flen] = 0;
   }
   /* free the buffers */  
   free(nnt_prog);
   free(nnt_res);
 }
 
 /* all other nntrac primitives */ 
 
 /* ps primitive: print string */
 char* prim_ps(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S);
   /* skip the first one (the ps string) */
   do {
     arg = strtok(NULL, NNT_ADEL_S);
     if(arg != NULL) printf("%s", arg);
   } while(arg != NULL);
   return res;
 }
 
 /* rc primitive: read char */
 char* prim_rc(char *arglist, char *res, int *reslen) {
   res = realloc(res, 1);
   res[0] = getchar();
   *reslen = 1;
   return res;
 }
 
 /* rs primitive: read string */
 char* prim_rs(char *arglist, char *res, int *reslen) {
   int c, i = 0;
   res = realloc(res, (*reslen) = 0);
   while((c = getchar()) > 0 && c != nnt_meta) {
     (*reslen)++;
     res = realloc(res, (*reslen) + 1);
     res[(*reslen) - 1] = c&255;
     res[*reslen] = 0; /* prefill with null terminator */
   }
   return res = realloc(res, (*reslen) = strlen(res));
 }
 
 /* cm primitive: change meta */
 char* prim_cm(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S);
   arg = strtok(NULL, NNT_ADEL_S);
   if(arg != NULL) nnt_meta = arg[0];
   return res;
 }
 
 /* ds primitive: define string (form) */
 char* prim_ds(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name, *value;
   name = strtok(NULL, NNT_ADEL_S); /* get the name */
   if(name != NULL) {
     value = strtok(NULL, NNT_ADEL_S); /* get the value */
     if(value != NULL) nnt_assignform(name, value, strlen(value), 0);
   }
   return res;
 }
 
 /* ss primitive: segment string (form) */
 char* prim_ss(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name, *seg, sid = 0;
   char idstr[3] = {NNT_SEGGAP, 0, 0}; /* update idstr[1] then */
   int fid = -1;
   /* skip the first one (the ps string) */
   name = strtok(NULL, NNT_ADEL_S); /* get the name */
   if(name != NULL && (fid = nnt_findform(name)) > -1) {
     do { /* receive the segment ids */
       seg = strtok(NULL, NNT_ADEL_S);
       if(seg != NULL) {
         sid++; /* we start from 1 to avoid null bytes */
         idstr[1] = sid; /* update the segmentid byte */
         nnt_forms[fid].value = nnt_replace(nnt_forms[fid].value, seg, idstr);
         nnt_forms[fid].len = strlen(nnt_forms[fid].value) + 1;
       }
     } while(seg != NULL);
   }
   nnt_forms[fid].fptr = 0;
   return res;
 }
 
 /* cr primitive: call restore */
 char* prim_cr(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name;
   int fid = -1;
   name = strtok(NULL, NNT_ADEL_S);
   if(name != NULL && (fid = nnt_findform(name)) > -1)
     nnt_forms[fid].fptr = 0;
   return res;
 }
 
 /* move form pointer helper */
 void nnt_moveptr(nnt_form *form, int offs) {
   int i = 0; if(offs < 1) offs = 1;
   for(i=0;i<offs;i++) {
     form->fptr++;
     while(form->value[form->fptr] == NNT_SEGGAP && form->fptr < form->len)
       form->fptr += 2; /* skip the gap and the segment id */
     if(form->fptr > form->len) {
       form->fptr = form->len;
       break;
     }
   }
 }
 
 /* partial character fetch helper (returns -1 if unavailable) */
 char nnt_fetchformchar(nnt_form *form, char dir) {
   if(dir >= 0) { /* move forward */
     while(form->value[form->fptr] == NNT_SEGGAP) {
       form->fptr += 2;
       if(form->fptr > form->len) { form->fptr = form->len; return -1; }
     }
   } else { /* move back */
     while(form->fptr >= 0 && form->value[form->fptr] == NNT_SEGGAP) {
       form->fptr--;
       if(form->fptr > 0 && form->value[form->fptr - 1] == NNT_SEGGAP)
         form->fptr--; /* skip the segment id byte */
       if(form->fptr < 0) { form->fptr = 0; return -1; }
     };
   }
   if(form->fptr >= 0 && form->fptr < form->len)
     return form->value[form->fptr];
   else return -1;
 }
 
 /* cs primitive: call segment */
 char* prim_cs(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name, *def;
   int fid = -1;
   name = strtok(NULL, NNT_ADEL_S);
   def = strtok(NULL, NNT_ADEL_S);
   if(name != NULL && (fid = nnt_findform(name)) > -1) {
     int sl; /* segment length */
     for(sl=0;sl<nnt_forms[fid].len;sl++)
       if(nnt_forms[fid].value[nnt_forms[fid].fptr+sl] == NNT_SEGGAP) break;
     if(nnt_forms[fid].fptr + sl > nnt_forms[fid].len)
       sl = nnt_forms[fid].len - nnt_forms[fid].fptr;
     if(sl > 0) {
       res = realloc(res, (*reslen) = sl);
       memcpy(res, &nnt_forms[fid].value[nnt_forms[fid].fptr], sl);
       nnt_moveptr(&nnt_forms[fid], sl); /* move the pointer */
     } else if(def != NULL) { /* set the default value */
       res = realloc(res, (*reslen) = strlen(def));
       memcpy(res, def, *reslen);    
     }
   }
   return res;
 }
 
 /* cc primitive: call character */
 char* prim_cc(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name, *def;
   int fid = -1;
   name = strtok(NULL, NNT_ADEL_S);
   def = strtok(NULL, NNT_ADEL_S);
   if(name != NULL && (fid = nnt_findform(name)) > -1) {
     res = realloc(res, (*reslen) = 1);
     res[0] = nnt_fetchformchar(&nnt_forms[fid], 1);
     if(res[0] == -1) { /* set the default value */
       if(def != NULL) {
         res = realloc(res, (*reslen) = strlen(def));
         memcpy(res, def, *reslen);
       } else *reslen = 0;
     }
     nnt_moveptr(&nnt_forms[fid], 1); /* move the pointer */
   }
   return res;
 }
 
 /* cn primitive: call N characters */
 char* prim_cn(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name, *offs, *def, c;
   int fid = -1, i, roff, ccount = 0;
   name = strtok(NULL, NNT_ADEL_S);
   offs = strtok(NULL, NNT_ADEL_S);
   def = strtok(NULL, NNT_ADEL_S);
   if(name != NULL && (fid = nnt_findform(name)) > -1) {
     roff = snum(offs); /* real offset */
     if(roff > 0) { /* positive offset */
       res = realloc(res, (*reslen) = roff + 1);
       memset(res, 0, *reslen);
       for(i=0;i<roff;i++) {
         c = nnt_fetchformchar(&nnt_forms[fid], 1);
         if(c < 0) break; else res[i] = c;
         nnt_forms[fid].fptr++; ccount++;
       }
       if(nnt_forms[fid].fptr > nnt_forms[fid].len)
         nnt_forms[fid].fptr = nnt_forms[fid].len;
       *reslen = strlen(res); /* update the length */
     } else if(roff < 0) { /* negative offset */
       roff = -roff; /* get absolute value */
       res = realloc(res, (*reslen) = roff + 1);    
       memset(res, 0, *reslen);
       nnt_forms[fid].fptr--; /* start counting from the previous char */
       for(i=0;i<roff;i++) {
         c = nnt_fetchformchar(&nnt_forms[fid], -1);
         if(c < 0) break; else res[i] = c;
         nnt_forms[fid].fptr--; ccount++;
       }
       if(nnt_forms[fid].fptr < 0) nnt_forms[fid].fptr = 0;
       *reslen = strlen(res); /* update the length */
       res = strrev(res); /* reverse the order */
     }
     if(ccount && *reslen) /* finalize the allocation */
       res = realloc(res, *reslen);
     else if(def != NULL) { /* return the default value */
       res = realloc(res, (*reslen) = strlen(def));
       memcpy(res, def, *reslen);
     } else *reslen = 0;
   }  
   return res;
 }
 
 /* in primitive: initial */
 char* prim_in(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *name, *subs, *def;
   name = strtok(NULL, NNT_ADEL_S);
   subs = strtok(NULL, NNT_ADEL_S);
   def = strtok(NULL, NNT_ADEL_S);
   int fid, i, slen;
   if(name != NULL && subs != NULL && (fid = nnt_findform(name)) > -1) {
     char *ntv = calloc(nnt_forms[fid].len + 1, 1); /* null-terminated value */
     memcpy(ntv, nnt_forms[fid].value, nnt_forms[fid].len);
     char *found = strstr(ntv, subs);
     if(found != NULL && nnt_forms[fid].fptr < nnt_forms[fid].len) {
       slen = ((long) (found - ntv)) - nnt_forms[fid].fptr;
       if(slen > 0) {
         res = realloc(res, slen + 1);
         memset(res, 0, slen + 1); /* null-terminate */
         for(i=0;i<slen;i++) { /* copy ignoring the seggaps */
           res[i] = nnt_fetchformchar(&nnt_forms[fid], 1);
           nnt_moveptr(&nnt_forms[fid], 1);
         }
         *reslen = strlen(res); /* update the length */
         res = realloc(res, *reslen); /* finalize */
         nnt_moveptr(&nnt_forms[fid], strlen(subs)); /* move after the fptr */
       } else found = NULL;
     } else found = NULL;
     if(found == NULL && def != NULL) { /* return the default value */
       res = realloc(res, (*reslen) = strlen(def));
       memcpy(res, def, *reslen);
     }
     free(ntv);
   }
   return res;
 }
 
 /* dd primitive: delete definition(s) */
 char* prim_dd(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S);
   do {
     arg = strtok(NULL, NNT_ADEL_S);
     if(arg != NULL) nnt_delform(arg);
   } while(arg != NULL);
   return res;
 }
 
 /* da primitive: delete all forms */
 char* prim_da(char *arglist, char *res, int *reslen) {
   int i = 0;
   for(i=0;i<nnt_forms_len;i++) free(nnt_forms[i].value);
   nnt_forms_len = 0;
   nnt_forms = realloc(nnt_forms, 0);
   return res;
 }
 
 /* eq primitive: string equality */
 char* prim_eq(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *x1, *x2, *x3, *x4;
   x1 = strtok(NULL, NNT_ADEL_S); x2 = strtok(NULL, NNT_ADEL_S);
   x3 = strtok(NULL, NNT_ADEL_S); x4 = strtok(NULL, NNT_ADEL_S);
   if(x1 && x2 && x3 && x4) {
     arg = strcmp(x1, x2) ? x4 : x3;
     *reslen = strlen(arg);
     res = realloc(res, *reslen);
     memcpy(res, arg, *reslen);
   }
   return res;
 }
 
 /* gr primitive: number inequality */
 char* prim_gr(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *d1, *d2, *x1, *x2;
   d1 = strtok(NULL, NNT_ADEL_S); d2 = strtok(NULL, NNT_ADEL_S);
   x1 = strtok(NULL, NNT_ADEL_S); x2 = strtok(NULL, NNT_ADEL_S);
   if(x1 && x2 && d1 && d2) {
     arg = (snum(d1) > snum(d2)) ? x1 : x2;
     *reslen = strlen(arg);
     res = realloc(res, *reslen);
     memcpy(res, arg, *reslen);
   }
   return res;
 }
 
 /* theoretically we can safely operate from -2**62 to 2**62 */
 #define ARITH_LIMIT ((long long) (((unsigned long long) - 1LL) >> 2))
 #define BITWISE_BITS 32
 #define BITWISE_LIMIT (unsigned long long) ((1LL<<BITWISE_BITS) - 1LL)
 
 /* reusable arithmetic ops helper */
 char* handle_dec_result(long long nres, char *ovr, char *res, int *reslen) {
   if(nres <= ARITH_LIMIT && nres > -ARITH_LIMIT) { /* valid result */
     res = n2s(nres, res, reslen);
   } else if(ovr) { /* return the overflow/underflow value */
     *reslen = strlen(ovr);
     res = realloc(res, *reslen); /* resize to actual length */
     memcpy(res, ovr, *reslen); /* fill the overflow value */
   }
   return res;
 }
 
 /* ad primitive: addition (overflow arg is optional) */
 char* prim_ad(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs, *ovr;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   ovr = strtok(NULL, NNT_ADEL_S);
   if(as && bs) res = handle_dec_result(snum(as) + snum(bs), ovr, res, reslen);
   return res;
 }
 
 /* su primitive: subtraction (overflow arg is optional) */
 char* prim_su(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs, *ovr;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   ovr = strtok(NULL, NNT_ADEL_S);
   if(as && bs) res = handle_dec_result(snum(as) - snum(bs), ovr, res, reslen);
   return res;
 }
 
 /* ml primitive: multiplication (overflow arg is optional) */
 char* prim_ml(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs, *ovr;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   ovr = strtok(NULL, NNT_ADEL_S);
   if(as && bs) res = handle_dec_result(snum(as) * snum(bs), ovr, res, reslen);
   return res;
 }
 
 /* dv primitive: division (overflow arg is optional) */
 char* prim_dv(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs, *ovr;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   ovr = strtok(NULL, NNT_ADEL_S);
   if(as && bs) {
    long long b = snum(bs);
    if(b) res = handle_dec_result(snum(as) / b, ovr, res, reslen);
    else if(ovr) { /* division by zero, return ovr */
      *reslen = strlen(ovr);
      res = realloc(res, *reslen); /* resize to actual length */
      memcpy(res, ovr, *reslen); /* fill the overflow value */
    }
   }
   return res;
 }
 
 /* bu primitive: bitwise union (OR) */
 char* prim_bu(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   if(as && bs) res = handle_dec_result((snum(as) | snum(bs)) & BITWISE_LIMIT, 
                        NULL, res, reslen);
   return res;
 }
 
 /* bi primitive: bitwise intersect (AND) */
 char* prim_bi(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   if(as && bs) res = handle_dec_result((snum(as) & snum(bs)) & BITWISE_LIMIT,
                        NULL, res, reslen);
   return res;
 }
 
 /* [new] bx primitive: bitwise exclusive or (XOR) */
 char* prim_bx(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   if(as && bs) res = handle_dec_result((snum(as) ^ snum(bs)) & BITWISE_LIMIT,
                        NULL, res, reslen);
   return res;
 }
 
 /* bc primitive: bitwise complement (NOT) */
 char* prim_bc(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as = strtok(NULL, NNT_ADEL_S);
   if(as) res = handle_dec_result((~snum(as)) & BITWISE_LIMIT,
                  NULL, res, reslen);
   return res;
 }
 
 /* br primitive: bitwise rotation */
 char* prim_br(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   if(as && bs) { 
     long long a = snum(as), b = snum(bs), nres;
     /* we rotate b according to the value of a */
     b &= BITWISE_LIMIT; /* bit-clip the value */
     if(a > 0) { /* rotate left */
       if(a > BITWISE_BITS) a %= BITWISE_BITS;
       nres = (b << a) | (b >> (BITWISE_BITS - a));
     } else if(a < 0) { /* rotate right */
       a = -a;
       if(a > BITWISE_BITS) a %= BITWISE_BITS;
       nres = (b << (BITWISE_BITS - a)) | (b >> a);
     }
     else nres = b; /* no rotation */
     res = handle_dec_result(nres & BITWISE_LIMIT, NULL, res, reslen);
   }
   return res;
 }
 
 /* bs primitive: bitwise shift */
 char* prim_bs(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *as, *bs;
   as = strtok(NULL, NNT_ADEL_S); bs = strtok(NULL, NNT_ADEL_S);
   if(as && bs) { 
     long long a = snum(as), b = snum(bs), nres;
     /* we shift b according to the value of a */
     if(a > 0) nres = b << a; /* shift left */
     else if(a < 0) nres = b >> (-a); /* shift right */
     else nres = b; /* no shift */
     res = handle_dec_result(nres & BITWISE_LIMIT, NULL, res, reslen);
   }
   return res;
 }
 
 /* ln primitive: list names */
 char* prim_ln(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *pref = strtok(NULL, NNT_ADEL_S);
   int i;
   for(i=0;i<nnt_forms_len;i++) {
     if(nnt_forms[i].name[0] != NNT_EOF) {
       if(pref) printf("%s", pref);
       printf("%s", nnt_forms[i].name);
     }  
   }
   return res;
 }
 
 /* pf primitive: print form */
 char* prim_pf(char *arglist, char *res, int *reslen) {
   char *arg = strtok(arglist, NNT_ADEL_S), *fname = strtok(NULL, NNT_ADEL_S);
   if(fname != NULL) {
     int i = nnt_findform(fname), j;
     if(i > -1) { /* form found */
       for(j=0;j<=nnt_forms[i].len;j++) {
         if(j == nnt_forms[i].fptr) printf("<^>");
         if(nnt_forms[i].value[j] == NNT_SEGGAP)
           printf("<%u>", (unsigned int) nnt_forms[i].value[++j]);
         else printf("%c",nnt_forms[i].value[j]);
       }
     }
   }
   return res;
 }
 
 /* filesystem primitives */
 
 /* sb primitive: store block */
 char *prim_sb(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_SECURE) return res; /* prevent running in secure mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *fname, *fmname;
   fname = strtok(NULL, NNT_ADEL_S);
   if(fname != NULL) { /* output file name */
     FILE *hnd = fopen(fname, "wb"); /* open the output file */
     if(hnd != NULL) {
       char *vbuf = malloc(0); /* value buffer */
       int findex, vlen = 0; /* value len */
       do {
         fmname = strtok(NULL, NNT_ADEL_S); /* form name */
         if(fmname != NULL) {
           findex = nnt_findform(fmname);
           if(findex > -1) {
             vbuf = nnt_serializeform(&nnt_forms[findex], vbuf, &vlen);
             fwrite(vbuf, vlen, 1, hnd); /* write the value out */
             nnt_delform(fmname); /* delete after exporting as per the spec */
           }
         }
       } while(fmname != NULL);
       fclose(hnd); /* close the output file */
       free(vbuf); /* free value buffer */
     }
   }  
   return res;
 }
 
 /* full file read helper */
 char* nnt_readfile(FILE *hnd, char *fbuf, int *buflen) {
   fseek(hnd, 0, SEEK_END);
   *buflen = ftell(hnd);
   fseek(hnd, 0, SEEK_SET);
   fbuf = realloc(fbuf, *buflen); /* allocate the full buffer */
   if(fbuf == NULL) return NULL; /* if allocation failed */    
   fread(fbuf, 1, *buflen, hnd); /* read the entire file */
   return fbuf;
 }
 
 /* fb primitive: fetch block */
 char *prim_fb(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_SECURE) return res; /* prevent running in secure mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *fname = strtok(NULL, NNT_ADEL_S);
   if(fname != NULL) { /* input file name */
     FILE *hnd = fopen(fname, "rb"); /* open the input file */
     if(hnd != NULL) {
       char *fbuf = malloc(0);
       int flen;
       fbuf = nnt_readfile(hnd, fbuf, &flen);
       fclose(hnd);
       int i = 0, dlen; /* running index and length */
       while(i < flen) { /* form queue to deserialize */
         dlen = nnt_deserializeform(&fbuf[i]);
         if(dlen < 0) break;
         i += dlen + 1;
       }
       free(fbuf); /* free file buffer */
     }
   }
   return res;
 }
 
 /* [new] sf primitive: store raw file */
 char *prim_sf(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_SECURE) return res; /* prevent running in secure mode */
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *fname, *fmname;
   fname = strtok(NULL, NNT_ADEL_S);  /* file name */
   fmname = strtok(NULL, NNT_ADEL_S); /* form name */
   if(fname != NULL && fmname != NULL) {
     int fid = nnt_findform(fmname);
     if(fid > -1) {
       FILE *hnd = fopen(fname, "wb"); /* open the output file */
       if(hnd != NULL) { /* write the value out */
         fwrite(nnt_forms[fid].value, nnt_forms[fid].len, 1, hnd); 
         fclose(hnd);
       }
     }
   }
   return res;
 }
 
 /* [new] ff primitive: fetch raw file */
 char *prim_ff(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_SECURE) return res; /* prevent running in secure mode */
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *fname, *fmname;
   fname = strtok(NULL, NNT_ADEL_S);  /* file name */
   fmname = strtok(NULL, NNT_ADEL_S); /* form name */
   if(fname != NULL && fmname != NULL) {
     FILE *hnd = fopen(fname, "rb"); /* open the input file */
     if(hnd != NULL) {
       char *fbuf = malloc(0);
       int flen;
       fbuf = nnt_readfile(hnd, fbuf, &flen);
       fclose(hnd);
       nnt_assignform(fmname, fbuf, flen, 0); /* store it into the form */
       free(fbuf); /* and free the resources */
     }  
   }
   return res;
 }
 
 /* eb primitive: erase block or raw file */
 char *prim_eb(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_SECURE) return res; /* prevent running in secure mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *fname = strtok(NULL, NNT_ADEL_S);
   if(fname != NULL) remove(fname); /* delete the input file name */
   return res;
 }
 
 /* mode primitive: set operation mode */
 char *prim_mo(char *arglist, char *res, int *reslen) {
   if(nnt_mlock == 1) return res; /* mode change is already locked */
   char *arg = strtok(arglist, NNT_ADEL_S), *modechar, *mlk;
   modechar = strtok(NULL, NNT_ADEL_S);
   if(modechar != NULL) {
     switch(modechar[0]) {
       case 'S': nnt_mode = NNT_SECURE; break;
       case 'L': nnt_mode = NNT_LEGACY; break;
       case 'E': nnt_mode = NNT_NORMAL; break;
     }
     mlk = strtok(NULL, NNT_ADEL_S);
     if(mlk != NULL && mlk[0] == 'L') nnt_mlock = 1; /* set mode lock */
   }
   return res;
 }
 
 /* [new] ac primitive: ASCII code */
 char *prim_ac(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *cvs = strtok(NULL, NNT_ADEL_S);
   if(cvs != NULL) res = n2s((uchar) cvs[0], res, reslen);
   return res;
 }
 
 /* [new] av primitive: ASCII value */
 char *prim_av(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *cns = strtok(NULL, NNT_ADEL_S);
   long long rcode = 0;
   if(cns != NULL) rcode = snum(cns);
   res = realloc(res, (*reslen) = 1);
   res[0] = rcode&255;
   return res;
 }
 
 /* [new] fn primitive: format number */
 char *prim_fn(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *fmt, *cns;
   fmt = strtok(NULL, NNT_ADEL_S);
   cns = strtok(NULL, NNT_ADEL_S);
   long long num = 0;
   if(fmt != NULL && cns != NULL) {
     num = snum(cns);
     *reslen = snprintf(NULL, 0, fmt, num); /* estimate the size */
     res = realloc(res, 1 + (*reslen));
     snprintf(res, 1 + (*reslen), fmt, num); /* actually format the number */
     res = realloc(res, (*reslen) = strlen(res)); /* final reallocation */   
   }
   return res;
 }
 
 #ifndef NNT_NO_EXTSHELL
 /* [new] os primitive: run external OS command */
 char *prim_os(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_SECURE) return res; /* prevent running in secure mode */
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *cmd = strtok(NULL, NNT_ADEL_S);
   int rescode;
   if(cmd != NULL) {
     rescode = system(cmd); /* run the command and get the status code */
     res = n2s(rescode, res, reslen);
   }
   return res;
 }
 #endif
 
 /* [new] tm primitive: local/UTC/Epoch time */
 char *prim_tm(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *fmt = strtok(NULL, NNT_ADEL_S),
        *opt = strtok(NULL, NNT_ADEL_S), utc = !!(opt!=NULL && opt[0]=='U');
   if(fmt != NULL) { /* format string exists */
     time_t curtime = time(NULL);
     if(fmt[0] == 'E' && fmt[1] == 0) res = n2s(curtime, res, reslen);
     else {
       struct tm *tminfo = utc ? gmtime(&curtime) : localtime(&curtime);
       res = realloc(res, (*reslen) = 512);
       memset(res, 0, *reslen);
       *reslen = strftime(res, *reslen, fmt, tminfo); /* populate the time */
       res = realloc(res, *reslen); /* shrink the result */
     }
   }
   return res;
 }
 
 static unsigned long long nnt_rngs; /* PRNG state*/    
 unsigned long long xorshift64s() {
   nnt_rngs^=(nnt_rngs>>12);nnt_rngs^=(nnt_rngs<<25);nnt_rngs^=(nnt_rngs>>27);
   unsigned long long inter = (nnt_rngs * 0x2545F4914F6CDD1DULL) >> 32;
   nnt_rngs^=(nnt_rngs>>12);nnt_rngs^=(nnt_rngs<<25);nnt_rngs^=(nnt_rngs>>27);
   return (inter << 32) | ((nnt_rngs * 0x2545F4914F6CDD1DULL) & 0xFFFFFFFF);
 }
 
 /* [new] rn primitive: (pseudo)random number */
 char *prim_rn(char *arglist, char *res, int *reslen) {
   if(nnt_mode == NNT_LEGACY) return res; /* prevent running in legacy mode */
   char *arg = strtok(arglist, NNT_ADEL_S), *froms = strtok(NULL, NNT_ADEL_S),
        *tos = strtok(NULL, NNT_ADEL_S);
   long long a = (froms == NULL) ? 0 : snum(froms),
             b = (tos == NULL) ? ARITH_LIMIT : snum(tos);
   res = n2s(a == b ? a : (a + xorshift64s() % (b - a)), res, reslen);
   return res;
 }
 
 /* init the resources and built-in primitives */
 void nnt_init() {
   nnt_forms = malloc(0); /* init the forms table */
   nnt_primitives = malloc(0); /* init the primitives table */
   nnt_rngs = time(NULL); xorshift64s(); /* init the PRNG */
   nnt_regprimitive("ps", &prim_ps);
   nnt_regprimitive("rc", &prim_rc);
   nnt_regprimitive("rs", &prim_rs);
   nnt_regprimitive("cm", &prim_cm);
   nnt_regprimitive("ds", &prim_ds);
   nnt_regprimitive("ss", &prim_ss);
   nnt_regprimitive("cl", &prim_cl);
   nnt_regprimitive("cr", &prim_cr);
   nnt_regprimitive("cc", &prim_cc);
   nnt_regprimitive("cs", &prim_cs);
   nnt_regprimitive("cn", &prim_cn);
   nnt_regprimitive("in", &prim_in);
   nnt_regprimitive("dd", &prim_dd);
   nnt_regprimitive("da", &prim_da);
   nnt_regprimitive("eq", &prim_eq);
   nnt_regprimitive("gr", &prim_gr);
   nnt_regprimitive("ad", &prim_ad);
   nnt_regprimitive("su", &prim_su);
   nnt_regprimitive("ml", &prim_ml);
   nnt_regprimitive("dv", &prim_dv);
   nnt_regprimitive("bu", &prim_bu);
   nnt_regprimitive("bi", &prim_bi);
   nnt_regprimitive("bx", &prim_bx);
   nnt_regprimitive("bc", &prim_bc);
   nnt_regprimitive("br", &prim_br);
   nnt_regprimitive("bs", &prim_bs);
   nnt_regprimitive("ln", &prim_ln);
   nnt_regprimitive("pf", &prim_pf);
   nnt_regprimitive("sb", &prim_sb);
   nnt_regprimitive("fb", &prim_fb);
   nnt_regprimitive("eb", &prim_eb);
   nnt_regprimitive("mo", &prim_mo);
   nnt_regprimitive("ac", &prim_ac);
   nnt_regprimitive("av", &prim_av);
   nnt_regprimitive("fn", &prim_fn);
   nnt_regprimitive("ff", &prim_ff);
   nnt_regprimitive("sf", &prim_sf);
 #ifndef NNT_NO_EXTSHELL
   nnt_regprimitive("os", &prim_os);
 #endif
   nnt_regprimitive("tm", &prim_tm);
   nnt_regprimitive("rn", &prim_rn);
 }
 
 /* free the interpreter resources */
 void nnt_finish() {  
   prim_da(NULL, nnt_res, &nnt_reslen); /* free internal form resources */
   if(nnt_primitives) free(nnt_primitives);
   if(nnt_forms) free(nnt_forms);
 } 
 
 /* non-embed entry point */
 #ifndef NNT_EMBED
 int main(int argc, char *argv[]) {
   char *fname = "-", *prog, *buf; /* stdin by default */
   int proglen, i, nlen;
   if(argc > 1) fname = argv[1];
   FILE* fd = stdin;
   if(!(fname[0] == '-' && fname[1] == 0)) {
     fd = fopen(fname, "rb");
     if(fd == NULL) {perror("Error");return 1;}
   }
   if(fd == stdin) { /* interactive session */
     proglen = strlen(prog = "#(ps,#(rs))");
     fprintf(stderr, "%s\n", "nntrac by Luxferre, 2023, public domain");
   } else prog = nnt_readfile(fd, malloc(0), &proglen);
   nnt_init(); /* init processing resources */
   if(argc > 1) { /* populate nnt-argc and nnt-argv forms */
     nlen = snprintf(NULL, 0, "%d", argc - 1);
     buf = calloc(nlen+1, 1);
     snprintf(buf, nlen+1, "%d", argc - 1);
     nnt_assignform("nnt-argc", buf, nlen, 0);
     buf = realloc(buf, 1); /* reuse the buffer for nnt-argv */
     buf[0] = 0; /* ensure it's an empty string */
     char segsep[3] = {NNT_SEGGAP, 1, 0};
     for(i=1,nlen=0;i<argc;i++) {
       nlen += strlen(argv[i]) + 2;
       buf = realloc(buf, nlen);
       strcat(buf, argv[i]); /* append the parameter */
       strcat(buf, segsep);  /* and the segment separator */
     }
     nnt_assignform("nnt-argv", buf, nlen, 0);
     free(buf);
   }
   nnt_proc(prog, proglen); /* start main processor */
   nnt_finish(); /* finalize processing resources */
   fclose(fd);
   puts(""); /* just print a newline before exiting */
   if(fd != stdin) free(prog); /* free the input buffer */
   return 0;
 }
 #endif