remove the teyjus and utils folders

1 files changed, 0 insertions, 617 deletions

diff --git a/src/runtime/c/teyjus/simulator/abstmachine.c b/src/runtime/c/teyjus/simulator/abstmachine.c
deleted file mode 100644
index a1b4da273..000000000
--- a/src/runtime/c/teyjus/simulator/abstmachine.c
+++ /dev/null
@@ -1,617 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//Copyright 2008
-//  Andrew Gacek, Steven Holte, Gopalan Nadathur, Xiaochu Qi, Zach Snow
-//////////////////////////////////////////////////////////////////////////////
-// This file is part of Teyjus.                                             //
-//                                                                          //
-// Teyjus is free software: you can redistribute it and/or modify           //
-// it under the terms of the GNU General Public License as published by     //
-// the Free Software Foundation, either version 3 of the License, or        //
-// (at your option) any later version.                                      //
-//                                                                          //
-// Teyjus is distributed in the hope that it will be useful,                //
-// but WITHOUT ANY WARRANTY; without even the implied warranty of           //
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            //
-// GNU General Public License for more details.                             //
-//                                                                          //
-// You should have received a copy of the GNU General Public License        //
-// along with Teyjus.  If not, see <http://www.gnu.org/licenses/>.          //
-//////////////////////////////////////////////////////////////////////////////
-
-/****************************************************************************/
-/*                                                                          */
-/*   File  abstmachine.c. This file defines the various registers,          */
-/*   data areas and record types and their operations  relevant to the      */
-/*   abstract machine.                                                      */
-/*                                                                          */
-/****************************************************************************/
-#ifndef ABSTMACHINE_C
-#define ABSTMACHINE_C
-
-#include   "mctypes.h"
-#include   "mcstring.h"
-#include   "dataformats.h"
-#include   "abstmachine.h"
-#include   "instraccess.h"
-#include   "../system/error.h"   
-#include   "../system/memory.h"  
-
-/****************************************************************************/
-/*                ABSTRACT MACHINE REGISTERS (AND FLAGS)                    */
-/****************************************************************************/
-AM_DataType  AM_regs[AM_NUM_OF_REG];//argument regs/temp variable
-//data register access: return the address of the ith register
-AM_DataTypePtr AM_reg(int i)        {  return (AM_regs + i);                 }
-
-MemPtr       AM_hreg;                //heap top
-MemPtr       AM_hbreg;               //heap backtrack point
-MemPtr       AM_ereg;                //current environment
-MemPtr       AM_breg;                //last choice point
-MemPtr       AM_b0reg;               //cut point
-MemPtr       AM_ireg;                //impl pt reg, defining prog context
-MemPtr       AM_cireg;               //impl pt for current clause 
-MemPtr       AM_cereg;               //closure environment  
-MemPtr       AM_tosreg;              //top of stack impl or choice pt.
-MemPtr       AM_trreg;               //trail top
-MemPtr       AM_pdlTop;              //top of pdl
-MemPtr       AM_pdlBot;              //(moving) bottom of pdl
-MemPtr       AM_typespdlBot;         //(moving) bottom of types pdl
-
-DF_TermPtr   AM_sreg;                //"structure" pointer 
-DF_TypePtr   AM_tysreg;              //type structure pointer
-
-CSpacePtr    AM_preg;                //program pointer
-CSpacePtr    AM_cpreg;               //continuation pointer
-
-Flag         AM_bndFlag;             //does binding of free var (term)  occur?
-Flag         AM_writeFlag;           //in write mode?
-Flag         AM_tyWriteFlag;         //in ty write mode? 
-Flag         AM_ocFlag;              //occurs check?
-
-Flag         AM_consFlag;            //cons?
-Flag         AM_rigFlag;             //rigid?
-
-//The size of AM_numAbs is decided by that of relevant fields in term
-//representations which can be found in dataformats.c
-TwoBytes     AM_numAbs;              //number of abstractions in hnf
-//The size of AM_numArgs is decided by that of relevant fields in term
-//representations which can be found in dataformats.c
-TwoBytes     AM_numArgs;             //number of arguments in hnf
-
-DF_TermPtr   AM_head;                //head of a hnf
-DF_TermPtr   AM_argVec;              //argument vector of a hnf 
-
-DF_TermPtr   AM_vbbreg;              //variable being bound for occ
-DF_TypePtr   AM_tyvbbreg;            //type var being bound for occ
-
-//The size of AM_adjreg is decided by that of relevant fields in term
-//representations which can be found in dataformats.c
-TwoBytes     AM_adjreg;              //univ count of variable being bound
-TwoBytes     AM_ucreg;               //universe count register
-
-DF_DisPairPtr AM_llreg;              //ptr to the live list
-
-/****************************************************************************/
-/*               STACK, HEAP, TRAIL AND PDL RELATED STUFF                   */
-/****************************************************************************/
-
-MemPtr     AM_heapBeg,                //beginning of the heap
-           AM_heapEnd,                //end of the heap
-           AM_stackBeg,               //beginning of the trail
-           AM_stackEnd,               //end of the trail
-           AM_trailBeg,               //beginning of the trail
-           AM_trailEnd,               //end of the trail
-           AM_pdlBeg,                 //beginning of pdl
-           AM_pdlEnd,                 //end of pdl
-           AM_fstCP;                  //the first choice point
-
-/****************************************************************************/
-/*            CODE PLACED IN THE HEAP BY THE SYSTEM                         */
-/****************************************************************************/
-CSpacePtr  AM_failCode;
-CSpacePtr  AM_andCode;
-CSpacePtr  AM_orCode;
-CSpacePtr  AM_allCode;
-CSpacePtr  AM_solveCode;
-CSpacePtr  AM_builtinCode;
-CSpacePtr  AM_eqCode;
-CSpacePtr  AM_stopCode;
-CSpacePtr  AM_haltCode;
-CSpacePtr  AM_notCode1;
-CSpacePtr  AM_notCode2;
-CSpacePtr  AM_proceedCode;
-
-
-Boolean    AM_isFailInstr(CSpacePtr cptr)    { return (cptr == AM_failCode); }
-/****************************************************************************/
-/*               VITUAL MACHINE MEMORY OPERATIONS                           */
-/****************************************************************************/
-//is the given addr referring to a register?
-Boolean AM_regAddr(MemPtr p)
-{
-  //TODO:
-  //  AM_reg lacked conversion to MemPtr; why is a function getting
-  //  converted in this way?
-  return ((((MemPtr)AM_reg) <= p) && (p < (MemPtr)((MemPtr)AM_reg + AM_NUM_OF_REG)));
-}
-//is the given addr on stack?
-Boolean AM_stackAddr(MemPtr p)    { return (p > AM_hreg);                      }
-//is the given addr not on heap?
-Boolean AM_nHeapAddr(MemPtr p)    { return ((p > AM_hreg) || (AM_heapBeg > p));}
-
- //is the "first" impl/impt record?
-Boolean AM_botIP(MemPtr p)        { return (p == AM_stackBeg);                 }
-//is the "first" choice point"?
-Boolean AM_botCP()                { return (AM_breg == AM_fstCP);              }
-//no env record left on the stack?
-Boolean AM_noEnv()                { return (AM_ereg == AM_stackBeg);           }
-
-
-MemPtr  AM_findtos(int i)
-{
-    return ((AM_tosreg > AM_ereg) ? AM_tosreg :
-            (MemPtr)(((AM_DataTypePtr)(AM_ereg + 2)) + i));
-} 
-MemPtr AM_findtosEnv()
-{
-    return ((AM_tosreg > AM_ereg) ? AM_tosreg :
-            (MemPtr)(((AM_DataTypePtr)(AM_ereg + 2))+INSACC_CALL_I1(AM_cpreg)));
-    
-}
-//set AM_tosreg to the top imp or choice pt
-void    AM_settosreg()       
-{
-    if (AM_ireg > AM_breg) AM_tosreg = AM_ireg + AM_IMP_FIX_SIZE;
-    else AM_tosreg = AM_breg + 1;
-}
-
-
-/***************************************************************************/
-/*               ENVIRONMENT RECORD OPERATIONS                             */
-/***************************************************************************/
-//environment record creation function
-MemPtr AM_mkEnv(MemPtr ep)                 //create the fixed part of env rec
-{
-    *((MemPtr *)(ep - 3)) = AM_cireg;             //CI field  
-    *((MemPtr *)(ep - 2)) = AM_ereg;              //CE field
-    *((int *)(ep - 1))    = AM_ucreg;             //UC field
-    *((CSpacePtr *)ep)    = AM_cpreg;             //CP field 
-    return (ep - 1);
-}
-MemPtr AM_mkEnvWOUC(MemPtr ep)              //ct fixed part of env without uc
-{
-    *((MemPtr *)(ep - 3)) = AM_cireg;             //CI field
-    *((MemPtr *)(ep - 2)) = AM_ereg;              //CE field
-    *((CSpacePtr *)ep)    = AM_cpreg;             //CP field
-    return (ep - 1);
-}
-
-//environment record access functions (current top-level env record)
-//the env continuation point 
-CSpacePtr AM_envCP()              { return *((CSpacePtr *)(AM_ereg + 1));}    
-//the uc value 
-int       AM_envUC()              { return *((int *)AM_ereg);            }
-//continuation point
-MemPtr    AM_envCE()              { return *((MemPtr *)(AM_ereg - 1));   }
-//impl point
-MemPtr    AM_envCI(MemPtr ep)     { return *((MemPtr *)(AM_ereg - 2));   }
-//the nth var fd 
-AM_DataTypePtr AM_envVar(int n)        
-{
-    return (AM_DataTypePtr)(((AM_DataTypePtr)AM_ereg) + n);
-}
-//is p an address in the current env?
-Boolean   AM_inCurEnv(MemPtr p)   { return (p > AM_ereg);                }
-
-//access functions for clause environment
-AM_DataTypePtr AM_cenvVar(int n)          //the nth var fd in clause env
-{
-    return (AM_DataTypePtr)(((AM_DataTypePtr)AM_cereg) + n);
-}
-    
-/****************************************************************************/
-/*                       CHOICE POINT OPERATIONS                            */
-/****************************************************************************/
-//choice point creation functions
-void AM_mkCP(MemPtr cp, CSpacePtr label, int n)  //create a choice pt
-{
-    *((MemPtr *)cp)              = AM_hreg;           //heap point
-    *((CSpacePtr *)(cp - 1))     = label;             //next clause ptr 
-    *((MemPtr *)(cp - 2))        = AM_trreg;          //trail point
-    *((DF_DisPairPtr *)(cp - 3)) = AM_llreg;          //live list 
-    *((MemPtr *)(cp - 4))        = AM_b0reg;          //cut point
-    *((MemPtr *)(cp - 5))        = AM_breg;           //previous choice pt
-    *((MemPtr *)(cp - 6))        = AM_cireg;          //clause context
-    *((MemPtr *)(cp - 7))        = AM_ireg;           //program context
-    *((CSpacePtr *)(cp - 8))     = AM_cpreg;          //cont. code ptr
-    *((MemPtr *)(cp - 9))        = AM_ereg;           //cont. env ptr
-    *((TwoBytes *)(cp - 10))     = AM_ucreg;          //universe count
-
-    for (; n > 0; n--)                                //save reg(1) to reg(n)
-        *(((AM_DataTypePtr)(cp - 10)) - n) = *AM_reg(n);
-}
-void AM_saveStateCP(MemPtr cp, CSpacePtr label)
-{
-    *((MemPtr *)cp)              = AM_hreg;           //heap point
-    *((CSpacePtr *)(cp - 1))     = label;             //next clause ptr 
-    *((MemPtr *)(cp - 2))        = AM_trreg;          //trail point
-    *((DF_DisPairPtr *)(cp - 3)) = AM_llreg;          //live list 
-    *((MemPtr *)(cp - 4))        = AM_b0reg;          //cut point
-    *((MemPtr *)(cp - 5))        = AM_breg;           //previous choice pt
-    *((MemPtr *)(cp - 6))        = AM_cireg;          //clause context
-    *((MemPtr *)(cp - 7))        = AM_ireg;           //program context
-    *((CSpacePtr *)(cp - 8))     = AM_cpreg;          //cont. code ptr
-    *((MemPtr *)(cp - 9))        = AM_ereg;           //cont. env ptr
-    *((TwoBytes *)(cp - 10))     = AM_ucreg;          //universe count
-}
-//set the next clause field in the current top choice point
-void AM_setNClCP(CSpacePtr ncl)
-{
-    *((CSpacePtr *)(AM_breg - 1)) = ncl;
-}
-
-
-//restore function
-//restore all components of a choice point except the trail top and the 
-//backtrack point registers 
-void AM_restoreRegs(int n)          
-{
-    for (; n > 0; n--) 
-        AM_regs[n] = *(((AM_DataTypePtr)(AM_breg - 10)) - n);
-
-    AM_hreg    = *((MemPtr *)AM_breg);
-    AM_llreg   = *((DF_DisPairPtr *)(AM_breg - 3));
-    AM_b0reg   = *((MemPtr *)(AM_breg - 4));
-    AM_cireg   = *((MemPtr *)(AM_breg - 6));
-    AM_ireg    = *((MemPtr *)(AM_breg - 7));
-    AM_cpreg   = *((CSpacePtr *)(AM_breg - 8));
-    AM_ereg    = *((MemPtr *)(AM_breg - 9));
-    AM_ucreg   = *((TwoBytes *)(AM_breg - 10));
-}
-//restore all components of a choice point except the trail top, the backtrack 
-//point and the clause context registers
-void AM_restoreRegsWoCI(int n)
-{
-    for (; n > 0; n--)
-        AM_regs[n] = *(((AM_DataTypePtr)(AM_breg - 10)) - n);
-
-    AM_hreg    = *((MemPtr *)AM_breg);
-    AM_llreg   = *((DF_DisPairPtr *)(AM_breg - 3));
-    AM_b0reg   = *((MemPtr *)(AM_breg - 4));
-    AM_ireg    = *((MemPtr *)(AM_breg - 7));
-    AM_cpreg   = *((CSpacePtr *)(AM_breg - 8));
-    AM_ereg    = *((MemPtr *)(AM_breg - 9));
-    AM_ucreg   = *((TwoBytes *)(AM_breg - 10));
-}
-
-//access functions
-MemPtr    AM_cpH()   { return *((MemPtr *)(AM_breg));        }
-CSpacePtr AM_cpNCL() { return *((CSpacePtr *)(AM_breg - 1)); }
-MemPtr    AM_cpTR()  { return *((MemPtr *)(AM_breg - 2));    } 
-MemPtr    AM_cpB()   { return *((MemPtr *)(AM_breg - 5));    }
-MemPtr    AM_cpCI()  { return *((MemPtr *)(AM_breg - 6));    }
-
-AM_DataTypePtr AM_cpArg(MemPtr cp, int n) //addr of nth arg in a given cp
-{
-    return ((AM_DataTypePtr)(cp - 10)) - n;
-}
-
-/***************************************************************************/
-/*                IMPLICATION/IMPORT RECORD OPERATIONS                     */
-/***************************************************************************/
-/* The tags for distinguishing implication and import records */
-typedef enum 
-{
-    AM_IMPTAG_IMPLICATION,                 //implication record
-    AM_IMPTAG_IMPTWOLOCAL,                 //import record without locals
-    AM_IMPTAG_IMPTWLOCAL                   //import record with locals
-} AM_ImpTag;
-
-//finding code for a predicate in the program context given by the value of
-//the AM_ireg. 
-void AM_findCode(int constInd, CSpacePtr *clPtr, MemPtr *iptr)
-{
-    CSpacePtr myclPtr = NULL;
-    MemPtr    myiptr  = AM_ireg;
-    int       size;    
-    while (!AM_botIP(myiptr)) {
-        if ((size = AM_impPSTS(myiptr)) && 
-            (myclPtr = (*(AM_impFC(myiptr)))(constInd,size,AM_impPST(myiptr))))
-            break;
-        else myiptr = AM_impPIP(myiptr); 
-    }
-    *clPtr = myclPtr;
-    *iptr  = myiptr;
-}
-//creating the fixed part of a new implication/import record
-void AM_mkImplRec(MemPtr ip, MemPtr sTab, int sTabSize, MEM_FindCodeFnPtr fnPtr)
-{
-    *((MemPtr *)ip)      = AM_ereg;                    //CE: clause env 
-    *(ip+1)              = (Mem)AM_IMPTAG_IMPLICATION; //tag 
-    *((MemPtr *)(ip+2))  = sTab;                       //PST: search table addr
-    *((MEM_FindCodeFnPtr *)(ip+3))  = fnPtr;           //FC: find code fn ptr 
-    *((MemPtr *)(ip+4))  = AM_ireg;                    //PIP: previous ip addr 
-    *((int *)(ip+5))     = sTabSize;                   //PSTS: search table size
-}
-
-//creating the fixed part of a new import record with local consts
-void AM_mkImptRecWL(MemPtr ip, int npreds, MemPtr sTab, int sTabSize, 
-                    MEM_FindCodeFnPtr fnPtr)
-{
-    *((int *)ip)         = npreds;                    //NPred: # preds 
-    *(ip+1)              = (Mem)AM_IMPTAG_IMPTWLOCAL; //tag 
-    *((MemPtr *)(ip+2))  = sTab;                      //PST: search table addr
-    *((MEM_FindCodeFnPtr *)(ip+3)) = fnPtr;           //FC: find code fn ptr
-    *((MemPtr *)(ip+4))  = AM_ireg;                   //PIP: previous ip addr
-    *((int *)(ip+5))     = sTabSize;                  //PSTS: search table size
-}
-//creating the fixed part of a new import record without local consts
-void AM_mkImptRecWOL(MemPtr ip, int npreds, MemPtr sTab, int sTabSize, 
-                     MEM_FindCodeFnPtr fnPtr)
-{
-    *((int *)ip)         = npreds;                    //NPred: # preds 
-    *(ip+1)              = (Mem)AM_IMPTAG_IMPTWOLOCAL;//tag 
-    *((MemPtr *)(ip+2))  = sTab;                      //PST: search table addr
-    *((MEM_FindCodeFnPtr *)(ip+3)) = fnPtr;           //FC: find code fn ptr
-    *((MemPtr *)(ip+4))  = AM_ireg;                   //PIP: previous ip addr
-    *((int *)(ip+5))     = sTabSize;                  //PSTS: search table size
-}
-
-//creating a dummy import point 
-void AM_mkDummyImptRec(MemPtr ip)
-{
-    *((int *)ip) = 0;
-    *(ip+1)      = (Mem)AM_IMPTAG_IMPTWOLOCAL;
-}
-
-
-/*initializing the next clause table in an implication/import record.*/
-void AM_mkImpNCLTab(MemPtr ip, MemPtr linkTab, int size)
-{
-    int       constInd;
-    CSpacePtr clausePtr;
-    MemPtr    iptr;
-    MemPtr    nextCl = AM_impNCL(ip, size);//the first entry in the NCL table
-    size--;
-    for (; size >= 0; size--) {
-        constInd = MEM_implIthLT(linkTab, size);
-        AM_findCode(constInd, &clausePtr, &iptr);
-        if (clausePtr) { //if found
-            *((CSpacePtr *)nextCl) = clausePtr; 
-            *((MemPtr *)(nextCl+1))= iptr;
-        } else {         //not found
-            *((CSpacePtr *)nextCl) = AM_failCode;
-            *((MemPtr *)(nextCl+1))= NULL;
-        }
-        nextCl += AM_NCLT_ENTRY_SIZE;
-    } //for loop
-}
-//initializing the backchained vector in an import record
-void AM_initBCKVector(MemPtr ip, int nclTabSize, int nSegs)
-{
-    MemPtr bcVecPtr = ip - nclTabSize - (AM_BCKV_ENTRY_SIZE * nSegs);
-    for (; (nSegs > 0); nSegs--){
-        *((int *)bcVecPtr)        = 0;     
-        *((MemPtr *)(bcVecPtr+1)) = AM_breg;
-        bcVecPtr += AM_BCKV_ENTRY_SIZE;
-    }
-}
-//set back chained number in a given back chained field
-void AM_setBCKNo(MemPtr bck, int n)          {  *((int *)bck) = n;             }
-//set most recent cp in a given back chained field
-void AM_setBCKMRCP(MemPtr bck, MemPtr mrcp)  {  *((MemPtr *)(bck+1)) = mrcp;   }
-//initializing the universe indices in the symbol table entries for constants
-//local to a module
-void AM_initLocs(int nlocs, MemPtr locTab)
-{
-    nlocs--;
-    for (; nlocs >= 0; nlocs--) 
-        AM_setCstUnivCount(MEM_impIthLCT(locTab, nlocs), AM_ucreg);
-}
-
-//implication/import record access functions
-//the ith entry of next clause tab 
-MemPtr    AM_impNCL(MemPtr ip, int i) {return (ip - AM_NCLT_ENTRY_SIZE * i);}
-//code in a next clause field
-CSpacePtr AM_impNCLCode(MemPtr ncl)   {return *((CSpacePtr *)ncl);          } 
-//ip in a next clause field      
-MemPtr    AM_impNCLIP(MemPtr ncl)     {return *((MemPtr *)(ncl+1));         }
-//the ith entry of back chained vec
-MemPtr    AM_cimpBCK(int i)  
-{ return (AM_cireg-AM_NCLT_ENTRY_SIZE*AM_cimpNPreds()-AM_BCKV_ENTRY_SIZE*i);  }
-//back chain num in a bck field 
-int       AM_impBCKNo(MemPtr bck)     {return *((int *)bck);                }
-//most recent cp is a bck field               
-MemPtr    AM_impBCKMRCP(MemPtr bck)   {return *((MemPtr *)(bck+1));         }
-//clause env of in imp rec referred to by cireg
-MemPtr    AM_cimpCE()                 {return *((MemPtr *)AM_cireg);        }
-//# preds of impt rec
-int       AM_cimpNPreds()             {return *((int *)AM_cireg);           }
- //search table addr 
-MemPtr    AM_impPST(MemPtr ip)        {return *((MemPtr *)(ip + 2));        }
-//find code function pointer
-MEM_FindCodeFnPtr AM_impFC(MemPtr ip) {return *((MEM_FindCodeFnPtr *)(ip + 3));}
-//PIP in given imp point
-MemPtr    AM_impPIP(MemPtr ip)        {return *((MemPtr *)(ip + 4));         }
-//previous ip in the current top imp point
-MemPtr    AM_curimpPIP()              {return *((MemPtr *)(AM_ireg + 4));    }
-//search table size
-int       AM_impPSTS(MemPtr ip)       {return *((int *)(ip + 5));            }
-
-
-Boolean AM_isImptWL(MemPtr ip) {           //is an imp rec a import rec w local
-    return ((AM_ImpTag)(*(ip+1)) == AM_IMPTAG_IMPTWLOCAL); 
-}
-Boolean AM_isImptWOL(MemPtr ip){           //is an imp rec a import rec wo local
-    return ((AM_ImpTag)(*(ip+1)) == AM_IMPTAG_IMPTWOLOCAL);
-}   
-Boolean AM_isImpl(MemPtr ip){              //is an imp rec a implication rec
-    return ((AM_ImpTag)(*(ip+1)) == AM_IMPTAG_IMPLICATION);
-}
-Boolean AM_isImpt(MemPtr ip){              //is an imp rec a import rec 
-    return ((AM_ImpTag)(*(ip+1)) != AM_IMPTAG_IMPLICATION);
-}
-
-Boolean AM_isImplCI(){                     //is rec referred to by CI impl?
-    return ((AM_ImpTag)(*(AM_cireg+1)) == AM_IMPTAG_IMPLICATION);
-}
-Boolean AM_isCurImptWL(){              //is rec referred to by I impt with loc?
-    return ((AM_ImpTag)(*(AM_ireg+1)) == AM_IMPTAG_IMPTWLOCAL); 
-}  
-
-/***************************************************************************/
-/*                     LIVE LIST OPERATIONS                                */
-/***************************************************************************/
-//live list is empty?
-Boolean AM_empLiveList() { return (AM_llreg == DF_EMPTY_DIS_SET);}
-
-//live list not empty?
-Boolean AM_nempLiveList(){ return (AM_llreg != DF_EMPTY_DIS_SET);}
-
-//add a dis pair to the live list when not knowning it is empty or not
-void    AM_addDisPair(DF_TermPtr tPtr1, DF_TermPtr tPtr2)
-{
-    MemPtr nhtop = AM_hreg + DF_DISPAIR_SIZE;
-    AM_heapError(nhtop);
-    DF_mkDisPair(AM_hreg, AM_llreg, tPtr1, tPtr2);
-    AM_llreg = (DF_DisPairPtr)AM_hreg;
-    AM_hreg = nhtop;
-}
-
-/***************************************************************************/
-/*                        PDL OPERATIONS                                   */
-/***************************************************************************/
-//pop (term/type) PDL
-MemPtr  AM_popPDL()              { return (MemPtr)(*(--AM_pdlTop));      }
-//push (term/type) PDL
-void    AM_pushPDL(MemPtr addr)  { (*AM_pdlTop++) = (Mem)addr;           }
-//is empty PDL?
-Boolean AM_emptyPDL()            { return (AM_pdlTop == AM_pdlBot);      }
-//is not empty PDL?
-Boolean AM_nemptyPDL()           { return (AM_pdlTop > AM_pdlBot);       }
-//initialize PDL
-void    AM_initPDL()             { AM_pdlTop = AM_pdlBot = AM_pdlBeg;    }
-//is empty type PDL?
-Boolean AM_emptyTypesPDL()       { return (AM_pdlTop == AM_typespdlBot); }
-//is not empty type PDL?
-Boolean AM_nemptyTypesPDL()      { return (AM_pdlTop > AM_typespdlBot);  }
-//initialize type PDL
-void    AM_initTypesPDL()        { AM_typespdlBot = AM_pdlTop;           }
-//recover type PDL to the status before type unification 
-void    AM_resetTypesPDL()       { AM_pdlTop = AM_typespdlBot;           }
-
-
-/****************************************************************************/
-/*                   RUN-TIME SYMBOL TABLES                                 */
-/****************************************************************************/
-MEM_KstPtr   AM_kstBase;     //starting addr of the kind symbol table
-MEM_TstPtr   AM_tstBase;     //starting addr of the type skel table
-MEM_CstPtr   AM_cstBase;     //starting addr of the const symbol table
-
-/* Kind symbol table                                                        */
-char* AM_kstName(int n)        //name of a type constructor in a given entry
-{
-    return MCSTR_toCString(
-        DF_strDataValue(((MEM_KstPtr)(((MemPtr)AM_kstBase)
-                                      + n*MEM_KST_ENTRY_SIZE)) -> name));
-}
-
-int   AM_kstArity(int n)       //arity of a type constructor in a given entry
-{
-    return ((MEM_KstPtr)(((MemPtr)AM_kstBase) + n*MEM_KST_ENTRY_SIZE)) -> arity;
-}
-
-/* Type skeleton table                                                      */
-DF_TypePtr AM_tstSkel(int n)   //type skeleton in a given entry
-{
-    return (DF_TypePtr)(((MemPtr)AM_tstBase) + n*MEM_TST_ENTRY_SIZE);
-}
-
-/* Constant symbol table                                                    */
-char* AM_cstName(int n)        //name of a constant in a given entry
-{
-  DF_StrDataPtr nameData = ((MEM_CstPtr)(((MemPtr)AM_cstBase) +
-					 n * MEM_CST_ENTRY_SIZE)) -> name;
-  if (nameData) return MCSTR_toCString(DF_strDataValue(nameData));
-  else return NULL;
-  //return MCSTR_toCString(
-  //    DF_strDataValue(((MEM_CstPtr)(((MemPtr)AM_cstBase) +
-  //                                    n*MEM_CST_ENTRY_SIZE)) -> name));
-}
-
-int   AM_cstTyEnvSize(int n)   //type environment size 
-{
-    return ((MEM_CstPtr)(((MemPtr)AM_cstBase)+n*MEM_CST_ENTRY_SIZE))->
-        typeEnvSize;
-}
-int   AM_cstNeeded(int n)      //neededness info
-{
-    return ((MEM_CstPtr)(((MemPtr)AM_cstBase)+n*MEM_CST_ENTRY_SIZE))->
-        neededness;
-    
-}
-int   AM_cstUnivCount(int n)   //universe count 
-{
-    return ((MEM_CstPtr)(((MemPtr)AM_cstBase)+n*MEM_CST_ENTRY_SIZE))->univCount;
-}
-int   AM_cstPrecedence(int n)  //precedence
-{
-    return ((MEM_CstPtr)(((MemPtr)AM_cstBase)+n*MEM_CST_ENTRY_SIZE))->
-        precedence;
-}
-int   AM_cstFixity(int n)      //fixity
-{
-    return ((MEM_CstPtr)(((MemPtr)AM_cstBase)+n*MEM_CST_ENTRY_SIZE))->fixity;
-}
-int   AM_cstTySkelInd(int n)   //type skeleton index
-{
-    return ((MEM_CstPtr)(((MemPtr)AM_cstBase)+n*MEM_CST_ENTRY_SIZE))->
-        tskTabIndex;
-}
-
-void AM_setCstUnivCount(int n, int uc)    //set universe count
-{
-    ((MEM_CstPtr)(((MemPtr)AM_cstBase)+n*MEM_CST_ENTRY_SIZE))->univCount = uc;
-}
-
-/****************************************************************************
- *                         OVERFLOW ERROR FUNCTIONS                         *
- ****************************************************************************/
-void AM_heapError(MemPtr p)                 //heap overflow
-{
-    if (AM_heapEnd < p) EM_error(SIM_ERROR_HEAP_OVERFL);
-}
-void AM_stackError(MemPtr p)               //stack overflow
-{
-    if (AM_stackEnd < p) EM_error(SIM_ERROR_STACK_OVERFL);
-}
-void AM_pdlError(int n)                    //pdl overflow for n cells
-{
-    if (AM_pdlEnd < (AM_pdlTop + n)) EM_error(SIM_ERROR_PDL_OVERFL);
-}
-void AM_trailError(int n)                  //trail overflow for n cells
-{
-    if (AM_trailEnd < (AM_trreg + n))
-        EM_error(SIM_ERROR_TRAIL_OVERFL);
-}
-
-  
-/****************************************************************************
- *                     MISCELLANEOUS OTHER ERRORS                           *
- ****************************************************************************/
-void AM_embedError(int n)     //violation of max number of lambda embeddings 
-{
-    if (n > DF_MAX_BV_IND)
-        EM_error(SIM_ERROR_TOO_MANY_ABSTRACTIONS, DF_MAX_BV_IND);
-}
-void AM_arityError(int n)    // violation of max number of arity in applications
-{
-    if (n > DF_TM_MAX_ARITY) EM_error(SIM_ERROR_TOO_MANY_ARGUMENTS, 
-                                      DF_TM_MAX_ARITY);
-}
-void AM_ucError(int n)      //violation of maximum of universe count
-{
-    if (n == DF_MAX_UNIVIND) EM_error(SIM_ERROR_TOO_MANY_UNIV_QUANTS);
-}
-
-#endif //ABSTMACHINE_C