////////////////////////////////////////////////////////////////////////////// //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 . // ////////////////////////////////////////////////////////////////////////////// /****************************************************************************/ /* */ /* 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