# PurposeByFile

```ab.c
/* Adverbs: b. bitwise functions                                           */

a.c

af.c

ai.c
/* Adverbs: Inverse & Identity Functions                                   */

am1.c
/* Adverbs: a ind}z for sparse z & ind is box a0;a1;a2;... or integer      */
/*  am1e    a is the sparse element                                        */
/*  am1a    a is an arbitrary dense array                                  */
/*  am1sp   a an arbitrary sparse array                                    */

am.c

amn.c
/* Adverbs: a ind}z where z is sparse and ind is <"1 integers              */
/*  amne    a is the sparse element                                        */
/*  amna    a is an arbitrary dense array                                  */
/*  amnsp   a an arbitrary sparse array                                    */

ao.c
/* Adverbs: Oblique and Key                                                */

ap.c
/* Adverbs: Prefix and Infix                                               */

ar.c
/* Adverbs: Reduce (Insert) and Outer Product                              */

as.c
/* Adverbs: Suffix and Outfix                                              */

au.c

ca.c
/* Conjunctions: Atop and Ampersand                                        */

c.c
/* Conjunctions                                                            */

cc.c
/* Conjunctions: Cuts                                                      */

cd.c
/* Conjunctions: Differentiation and Integration                           */

cf.c
/* Conjunctions: Forks                                                     */

cg.c
/* Conjunctions: Gerunds ` and `:                                          */

ch.c
/* Conjunctions: Hypergeometric Series                                     */

cip.c
/* Conjunctions: Inner Product                                             */

cl.c
/* Conjunctions: L: and S:                                                 */

cp.c
/* Conjunctions: Power Operator ^: and Associates                          */

cpdtsp.c
/* Conjunctions: Dyad +/ .* on Sparse Arguments                            */

cr.c
/* Conjunctions: Rank Associates                                           */

crs.c
/* Conjunctions: Rank on Sparse Arrays                                     */

ct.c
/* Conjunctions: Taylor's Series                                           */

cu.c
/* Conjunctions: Under and Each                                            */

cv.c
/* Conjunctions: Variants (!.)                                             */

cx.c
/* Conjunctions: Explicit Definition : and Associates                      */

/* Usage of the f,g,h fields of : defined verbs:                           */
/*  f  character matrix of  left argument to :                             */
/*  g  character matrix of right argument to :                             */
/*  h  4-element vector of boxes                                           */
/*       0  vector of boxed tokens for f                                   */
/*       1  vector of triples of control information                       */
/*       2  vector of boxed tokens for g                                   */
/*       3  vector of triples of control information                       */

d.c
/* Debug: Error Signalling and Display                                     */

dc.c
/* Debug: Function Call Information                                        */

dss.c
/* Debug: Single Step                                                      */

dstop.c
/* Debug: Stops                                                            */

dsusp.c
/* Debug: Suspension                                                       */

dtoa.c

f2.c

f.c

i.c
/* Initializations                                                         */

io.c
/* Input/Output                                                            */

j.c
/* Global Variables                                                        */

jconsole.c
/* J console */
jdlllic.c
/* encode/decode routines - license keys and ijl                           */
k.c
/* Conversions Amongst Internal Types                                      */

mbx.c
/* Memory-Mapped Boxed Arrays                                              */

m.c
/* Memory Management                                                       */

p.c
/* Parsing; see APL Dictionary, pp. 12-13 & 38.                            */

pv.c
/* Parsing: Tacit Verb Translator (13 : )                                  */

px.c
/* Execute and Associates                                                  */

/* Variables for controlling execution                                     */
/* B     asgn      1 iff last operation on this line is assignment         */
/* DC    dcs       ptr to debug stack entry for current script             */
/* I     etxn      strlen(etx)                                             */
/* C     etx[]     space for holding error display                         */
/* I     jbrk      1 iff user has entered "break"                          */
/* C     jerr      error number for this line                              */
/* A     slist     script files used in right argument to 0!:              */
/* I     slisti    index in slist for current script                       */
/* I     slistn    slist # real entries; AN(slist) is reserved entries     */
/* B     tostdout  1 iff output to standard output                         */

r.c
/* Representations: Atomic, Boxed, and 5!:0                                */

rl.c
/* Representations: Linear and Paren                                       */

rt.c
/* Representations: Tree                                                   */

s.c
/* Symbol Table                                                            */

sc.c
/* Symbol Table: Function Call (unquote)                                   */

sl.c
/* Symbol Table: Locales                                                   */

sn.c
/* Symbol Table: Names                                                     */

t.c
/* Table of Primitive Symbols                                              */

tsdll.c
u.c
/* Interpreter Utilities                                                   */

v0.c
/* Verbs: Polynomial Roots & Polynomial Evaluation                         */

v1.c
/* Verbs: Match Associates                                                 */

v2.c
/* Verbs: Primes and Factoring                                             */

va1.c

va2.c
/* Verbs: Atomic (Scalar) Dyadic                                           */

va2s.c
/* Verbs: Atomic (Scalar) Dyadic Verbs on Sparse Arrays                    */

vamultsp.c
/* Verbs: "Multiplication" on Sparse Arrays                                */

vbang.c
/* Verbs: !                                                                */

vb.c
/* Verbs: Boolean-Valued                                                   */

vbit.c
/* Verbs: Bit Type                                                         */

/* 1 bit per element                                                       */
/* total # elements <: IMAX                                                */
/* dimension length <: IMAX                                                */
/* last dimension internally padded with 0s up to fullword                 */

v.c
/* Verbs                                                                   */

vcant.c
/* Verbs: Transpose                                                        */

vcat.c
/* Verbs: Catenate and Friends                                             */

vcatsp.c
/* Verbs: ,. on Sparse Arguments of rank 2 or less                         */

vchar.c
/* Verbs: Character Functions  u&(a.&i.) and u&.(a.&i.)                    */

vcomp.c
/* Verbs: Comparatives                                                     */

vcompsc.c
/* Verbs: Comparatives                                                     */
/* Special code for the following cases:                                   */
/*    comp i. 0:          i.&0@:comp                                       */
/*    comp i. 1:          i.&1@:comp                                       */
/*    comp i: 0:          i:&0@:comp                                       */
/*    comp i: 1:          i:&1@:comp                                       */
/*    [: + / comp         + /@:comp                                        */
/*    [: +./ comp         +./@:comp   1: e. comp                           */
/*    0: e. comp                                                           */
/*    [: I. comp          I.@:comp                                         */
/* where comp is one of the following:                                     */
/*    = ~: < <: >: > E. e.                                                 */

vd.c
/* Verbs: Domino                                                           */

vdx.c
/* Verbs: Extended Precision Floating Point                                */

ve.c
/* Verbs: Elementary Functions (Arithmetic, etc.)                          */

vf.c
/* Verbs: Fill-Dependent Verbs                                             */

vfft.c
/* Verbs: Fast Fourier Transform and Friends                               */

vfrom.c
/* Verbs: From & Associates. See Hui, Some Uses of { and }, APL87.         */

vfromsp.c
/* Verbs: { on sparse arguments                                            */

vgauss.c
/* Verbs: Gaussian Elimination                                             */

vg.c

vgcomp.c
/* Verbs: Grade -- Compare                                                 */
/* the result of a CF comparison fn is 1 if (a{w)>(b{w), -1 otherwise      */

vgranking.c

vgsort.c

vgsp.c
/* Verbs: Grades on Sparse Arrays                                          */

vi.c
/* Verbs: Index-of                                                         */

viix.c
/* Verbs: Interval Index, mostly by Binary Search                          */

visp.c
/* Verbs: Index-of on Sparse Arrays                                        */

vm.c
/* Verbs: "Mathematical" Functions (Irrational, Transcendental, etc.)      */

vo.c
/* Verbs: Box & Open                                                       */

vp.c
/* Verbs: Permutations                                                     */

vq.c
/* Verbs: Rational Numbers                                                 */

vrand.c
/* Verbs: Random Numbers                                                   */

vrep.c
/* Verbs: a#"r w                                                           */

vsb.c
/* Verbs: s:                                                               */

vs.c
/* Verbs: \$. Sparse Arrays                                                 */

vt.c
/* Verbs: Take and Drop                                                    */

vu.c
/* Unicode (2-byte unsigned characters)                                    */

vx.c
/* Verbs: Extended Precision Integers                                      */

vz.c
/* Verbs: Complex-Valued Scalar Functions                                  */

w.c
/* Words: Word Formation                                                   */

wc.c
/* Words: Control Words                                                    */

wn.c
/* Words: Numeric Input Conversion                                         */

ws.c
/* Words: Spelling                                                         */

x15.c
/* Xenos: DLL call driver                                                  */

/*
xa.c
/* Xenos: Miscellaneous                                                    */

xb.c
/* Xenos: Binary Representation                                            */

x.c
/* Xenos aka Foreign: External, Experimental, & Extra                      */

xc.c
/* Xenos: Custom                                                           */

xcrc.c
/* Xenos: CRC calculation                                                  */

xd.c
/* Xenos: file directory, attributes, & permission                         */

xf.c
/* Xenos: Files                                                            */

/* File functions accept file number or boxed file name or 1 or 2          */

xfmt.c
/* Xenos: 8!:x formatting stuff                                            */

xh.c
/* Xenos: Host Command Facilities                                          */

xi.c
/* Xenos: Implementation Internals                                         */

xl.c
/* Xenos: File Lock/Unlock                                                 */

xo.c
/* Xenos: File Open/Close                                                  */

xs.c
/* Xenos: Scripts                                                          */

xt.c
/* Xenos: time and space                                                   */

xu.c
/* Xenos: u: conversions                                                   */
```