Nouns
An Implementation of J

   typedef long I;
   typedef struct {I k,flag,m,t,c,n,r,s[1];}* A;

     k   flag  m    t    c    n    r   s[0]
   ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
   │  32│   0│  20│CHAR│   2│  17│   1│  17│Cogi│to, │ergo│ sum│.   │
   └────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

     k   flag  m    t    c    n    r
   ┌────┬────┬────┬────┬────┬────┬────┬────┬────┐
   │  28│   0│   8│  FL│   2│   1│   0│  1.61803│
   └────┴────┴────┴────┴────┴────┴────┴────┴────┘

     k   flag  m    t    c    n    r   s[0] s[1]
   ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬
   │  36│   0│  48│ INT│   2│  12│   2│   3│   4│  11│  12│  13│
   └────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴
                       ┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
                       │  14│  15│  16│  17│  18│  19│  20│  21│  22│
                       ┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

   GA(xyz,t,n,r,s);

   typedef char   C;
   typedef double D;

   A ces,m,phi; I j,*s,*v;

   GA(ces,CHAR,17,1,0);
   memcpy((C*)AV(ces),"Cogito, ergo sum.",(size_t)17);

   GA(phi,FL,1,0,0);
   *(D*)AV(phi)=1.61803;

   GA(m,INT,12,2,0);
   s=AS(m); *s=3; *(1+s)=4;
   v=AV(m); for(j=11;23>j;++j)*v++=j;

Types

If x is an array, its type AT(x) specifies how the atoms starting at AV(x) are to be interpreted. In C programming terms, AV(x) must be cast to a pointer of the appropriate C type:

           C Data
   AT(x)    Type                    Description

   B01       B          Boolean (BOOL has a name conflict)                    
   LIT       C          literal (character; CHAR has a name conflict)        
   INT       I          integer                     
   FL        D          double (IEEE floating point)
   CMPX      Z          complex                   
   BOX       A          boxed                      
   XNUM      X          extended precision integer
   RAT       Q          rational number          

   SB01      P          sparse boolean        
   SLIT      P          sparse literal (character)
   SINT      P          sparse integer       
   SFL       P          sparse floating point
   SCMPX     P          sparse complex        
   SBOX      P          sparse boxed             

   VERB      V          verb                    
   ADV       V          adverb                  
   CONJ      V          conjunction   
         
   ASGN      I          assignment              
   MARK      I          marker     
   SYMB      L          locale (symbol table)     
   CONW      CW         control word             
   NAME      NM         name                     
   LPAR      I          left  parenthesis        
   RPAR      I          right parenthesis       

   #define NUMERIC (B01+INT+FL+CMPX+XNUM+RAT+SB01+SINT+SFL+SCMPX)
   #define NOUN    (NUMERIC+LIT+SLIT+BOX+SBOX)

   #define R  return

   A aib(A x){A*u,z;I j,*v;
    GA(z,INT,AN(x),AR(x),AS(x));       /* 1 */
    u=(A*)AV(x); v=AV(z);              /* 2 */
    for(j=0;AN(x)>j;++j)*v++=AN(*u++); /* 3 */
    R z;
   }

Memory Management

When an array is created, malloc is called to obtain the requisite storage; when this storage is no longer needed, free is called to return it to the underlying system. No "garbage collection" is done. The performance of this strategy is adequate on modern virtual memory systems. To facilitate the implementation of alternative strategies, the use of malloc and free is limited to a single instance of each, in the file m.c.

The reference count of an array is incremented when it is assigned a name, directly or indirectly, and is decremented when the name is reassigned or erased; when the reference count of an array reaches 0, its storage is freed.

When an array is created, a pointer to it is entered in a "temp stack" (tstack in file m.c.) A temp is an array on this stack with a reference count of one. The temp stack plays an important role in the main execution loop. In an iteration of the loop,

   • The top of the temp stack is recorded;
   • A line of user-input is executed; and
   • Temps from the current top-of-stack to the old top-of-stack recorded above, are freed.

This device permits functions to be written without explicit memory management code. For example, the monad ~. is written:

   F1(jtnub){R repeat(nubsieve(w),w);}

Global Variables

The only global variables used in the system are constants which are assigned exactly once. (For example, the array constant zero and the internal complex number zeroZ.) All other variables non-local to functions are accessed through the parameter jt.

jt has defined type J, a pointer to a struct defined in file jt.h. Nearly all functions in the system has jt as its first function argument, and all such functions have the letters jt as a prefix in their names. The file ja.h defines aliases for these names, so that a call to a function jtxyz(jt,a,w,h) is actually written as xyz(a,w,h). For example, the conjunction &, described in Adverbs and Conjunctions, is implemented by a function defined and declared as jtamp, having prototype A jtamp(J jt,A a,A w), but calls to this function are written as amp(a,w), and discussions on this function refer to it as amp.

jt makes it possible to execute multiple instances of J in the same process.