/* Copyright (C) 1993 by Thomas Glen Smith. All Rights Reserved. */
/* aplfunc.h APL2 V1.0.0 ************************************************
* This structure is used to fix user-defined functions in the workspace.*
* r/w-Execqfx* "fixes" functions. They're called with an aplcb *
* containing the character representation of the function. *
* r -Funcexec, which is called by funcmain after variables have been *
* localized, gets its pointer to the aplfunc structure from *
* treehdr->avlfun. *
* r -Funcexee is called by funcexec after stop control is handled to *
* execute the next function statement. It too gets its aplfunc *
* pointer from treehdr->avlfun. *
* r -Funcinit is called by funcmain to initialize local variables. It *
* is passed pointers to the aplfunc structure, and the left and *
* arguments to the function, if they exist. *
* r/w-Funcmain is called by execnila, execdyan, and execmons, with *
* pointers to the aplfunc structure and any arguments to the *
* user-defined function. It checks the APLFUNC_IN_USE flag, and *
* makes a copy of aplfunc, if so. It also turns on APLFUNC_IN_USE *
* at the start, and off again at the end of execution. *
* r -Aplcpyc calls execqfx, passing it functext, during a )COPY *
* operation when the item to copy is a user-defined function. *
* r -Aplediu is called from apledit to prepare a niladic function for *
* editing. *
* r -Aplediw is called from aplediu to prepare a function for editing. *
* r -Execexei is called by execexee to execute the operand token, if *
* it represents a niladic user-defined function. *
* r -Execnila is called from execexei to execute a niladic user *
* defined function. *
* r -Execqcr is called from execmonq to obtain the character *
* representation of a user-defined function. *
* r/w-Expunge is called from execqex and execqfxb to expunge a user *
* defined function. *
* r -Funcgoto is called by funcexec when a branch is to be made. *
* r -Funcmsg is called by funcexec to generate an error message. *
* r/w-Lovfsfn is called to read a function definition during a )LOAD. *
* r -Treeroot assigns its aplfunc argument to the new avlfun root. *
************************************************************************/
#if !defined(APLFUNC_INCL)
#define APLFUNC_INCL
#define NILAD 256
#define MONAD 512
#define DYAD 1024
#define RETVAL 2048
#define MOP 4096
#define DOP 8192
typedef struct aplfunc *Aplfunc;
struct aplfunc {
struct aplfunc *funcsiqp; /* Used for stacking operations. */
/* Execqfxa assigns NULL. No other reference. */
/* Funcsiqp m/b defined so funcflag will be in */
/* the same relative position as aplflags in */
/* an aplcb structure, because avlnodes can point */
/* to both aplcbs and aplfuncs. */
int funcflag; /* Always 256 to indicate fixed function */
/* Ref: execexee, execexei, execqfxa, funcmain, */
/* lovfsfn savfsfn. */
int functype; /* Ref: apledit, execexei, execnila, execqfxa, */
/* execqfxd execqfxg, funcinit, funcopy, */
/* funcmain, funcopy, lovfsfn. */
/* 256 = niladic, F */
/* 512 = monadic, F r */
/* 1024 = dyadic, l F r */
/* 2048 = result, z # F */
/* z # F r */
/* z # l F r */
/* z # (lo mop) r */
/* z # l (lo mop) r */
/* z # (lo dop ro) r */
/* z # l (lo dop ro) r */
/* 4096 = monadic operator */
/* (lo mop) r */
/* l (lo mop) r */
/* 8192 = dyadic operator */
/* (lo dop ro) r */
/* l (lo dop ro) r */
int functotl; /* Count of tokens in functary. */
/* Ref: apledcl, apledit, aplediv, execexee, */
/* execqfxam expunge, execqfxk, funcopy, */
/* lovfsfn, lovfsfo, lovfsfp, savfsfn, */
/* savfsfo. */
int funcstmt; /* Count of statements in function. */
/* Ref: apledit, aplediw, execqfxa, execqfxb, */
/* execqfxf, execqfxj, execqfxk, funcopy, */
/* funcexec, funcexef, funcgoto, funcopy, */
/* functrgo, lovfsfn. */
int *functokc; /* Array of token counters, one per statement. */
/* For statements with labels, this count will */
/* be reduced by 2. */
/* Ref: apledcl, aplediu, aplediv, aplediw, */
/* apledrc, execqfxa, execqfxd, execqfxf, */
/* execqfxj, execqfxk, expunge, funcexee, */
/* funcopy, lovfsfn, savfsfn. */
struct aplcb *functext; /* Pointer to function text. */
/* Ref: aplcpyc, aplediw, execqcr, execqfxa, */
/* execqfxb, expunge, funcmsg, funcopy, */
/* lovfsfn, savfsfn. */
struct apltoken *funcname; /* Pointer to function name token. */
/* Ref: aplediv, execqfxa, execqfxl, funcexec, */
/* funcmsg, funcopy, functrac, functrgo, */
/* lovfsfp, savfsfn, treeroot. */
struct apltoken **functokp; /* Ptr to array of token headers, */
/* one for each statement in the function. */
/* The queue of tokens gets altered during */
/* statement execution. */
/* Ref: apledcl, apleddl, apledit, aplediu, */
/* aplediv, aplediw, aplediy, apledmd, */
/* aplednw, apledqu, apledrc, execqfxa, */
/* execqfxb, execqfxd, execqfxf, execqfxj, */
/* execqfxk, expunge, funcexee, funcopy, */
/* lovfsfn, lovfsfp, savfsfn. */
struct apltoken *functary; /* Memory for all tokens is obtained */
/* once. This points to that block of memory. */
/* Ref: apledcl, aplediv, execqfxa, execqfxb, */
/* execqfxk, expunge, funcopy, lovfsfn, */
/* lovfsfo, lovfsfp, savfsfn, savfsfo. */
struct apltoken *funcvars; /* List of local variables. */
/* Ref: execqfxa, execqfxd, execqfxg, execqfxi, */
/* funcinit, funcmain, funcopy, lovfsfp, */
/* savfsfn. */
/* The variable to contain the returned value, if */
/* there is a returned value, will be first in */
/* this list. If the function is dyadic, the left*/
/* operand will be next, followed by the right */
/* operand, if the function is either dyadic or */
/* monadic. The rest of the list is the local */
/* variables as indicated on the function header. */
struct apltoken *funclabs; /* List of labels. */
/* Ref: aplediw, execqfxa, execqfxf, execqfxi, */
/* funcinit, funcopy, lovfsfp, savfsfn. */
/* Token_offset will contain the number of the */
/* statement with the given label. */
};
#endif
