gf-3.4: src/runtime/c/teyjus/simulator/siminit.c
//////////////////////////////////////////////////////////////////////////////
//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 siminit.c. */
/**************************************************************************/
#ifndef SIMINIT_C
#define SIMINIT_C
#include "siminit.h"
#include "abstmachine.h"
#include "dataformats.h"
#include "io-datastructures.h"
#include "builtins/builtins.h"
#include "../tables/instructions.h"
#include "../system/error.h"
#include "../system/message.h"
#include <stdio.h>
/***************************######********************************************
* ERROR INFORMATION
*********************************######**************************************/
static MSG_Msg SIM_errorMessages[SIM_NUM_ERROR_MESSAGES] =
{
{ SIM_ERROR,
0,
"Simulator: ",
0, 0, 0 },
{ SIM_ERROR_TOO_MANY_ABSTRACTIONS,
SIM_ERROR,
"Abstraction embedding depth has exceeded maximum of %d.",
EM_NEWLINE, EM_TOP_LEVEL, 4 },
{ SIM_ERROR_TOO_MANY_ARGUMENTS,
SIM_ERROR,
"Application arguments has exceeded maximum of %d.",
EM_NEWLINE, EM_TOP_LEVEL, 4 },
{ SIM_ERROR_TOO_MANY_UNIV_QUANTS,
SIM_ERROR,
"Too many universal quantifiers.",
EM_NEWLINE, EM_TOP_LEVEL, 3 },
{ SIM_ERROR_HEAP_TOO_BIG,
SIM_ERROR,
"Specified heap size (%uK) is larger than maximum of 256Gb.",
EM_NEWLINE, EM_ABORT, 1 },
{ SIM_ERROR_HEAP_TOO_SMALL,
SIM_ERROR,
"Specified heap size (%uK) is smaller than minimum of 10K.",
EM_NEWLINE, EM_ABORT, 1 },
{ SIM_ERROR_CANNOT_ALLOCATE_HEAP,
SIM_ERROR_CANNOT_ALLOCATE_HEAP_MESSAGE,
"",
SIM_ERROR_CANNOT_ALLOCATE_HEAP_SUGGESTION, EM_ABORT, 1 },
{ SIM_ERROR_CANNOT_ALLOCATE_HEAP_MESSAGE,
SIM_ERROR,
"Could not allocate heap of size %uK at 0x%08x using %s.",
EM_NEWLINE, EM_NO_EXN, 1 },
{ SIM_ERROR_CANNOT_ALLOCATE_HEAP_SUGGESTION,
SIM_ERROR,
"Try modifying the configuration and recompiling.",
EM_NEWLINE, EM_NO_EXN, 1 },
{ SIM_ERROR_TRAIL_OVERFL,
SIM_ERROR,
"Trail overflow.",
EM_NEWLINE, EM_TOP_LEVEL, 1 },
{ SIM_ERROR_HEAP_OVERFL,
SIM_ERROR,
"Heap overflow.",
EM_NEWLINE, EM_TOP_LEVEL, 1 },
{ SIM_ERROR_STACK_OVERFL,
SIM_ERROR,
"Stack overflow.",
EM_NEWLINE, EM_TOP_LEVEL, 1 },
{ SIM_ERROR_PDL_OVERFL,
SIM_ERROR,
"PDL overflow.",
EM_NEWLINE, EM_TOP_LEVEL, 1 }
};
/*************************************************************************/
/* SETTING UP SPECIAL CODE SEGMENTS */
/*************************************************************************/
static const int SINIT_initSize = 31;
static void SINIT_initCode()
{
MemPtr nhreg = AM_hreg + SINIT_initSize;
CSpacePtr myhreg = (CSpacePtr)AM_hreg;
AM_heapError(nhreg);
//builtinCode
AM_builtinCode = myhreg;
*((INSTR_OpCode*)myhreg) = builtin; //builtin ...
myhreg += INSTR_I1X_LEN;
//eqCode
AM_eqCode = myhreg;
*((INSTR_OpCode*)myhreg) = pattern_unify_t; //pattern_unify A1, A2
*((INSTR_RegInd*)(myhreg + INSTR_RRX_R1)) = 1;
*((INSTR_RegInd*)(myhreg + INSTR_RRX_R2)) = 2;
myhreg += INSTR_RRX_LEN;
*((INSTR_OpCode*)myhreg) = finish_unify; //finish_unify
myhreg += INSTR_X_LEN;
*((INSTR_OpCode*)myhreg) = proceed; //proceed
myhreg += INSTR_X_LEN;
//failCode
AM_failCode = myhreg;
*((INSTR_OpCode*)myhreg) = fail; //fail
myhreg += INSTR_X_LEN;
//andCode
*((INSTR_OneByteInt*)(myhreg + INSTR_I1LX_I1)) = 2;//"call" 2 L
myhreg += INSTR_I1LX_LEN;
AM_andCode = myhreg;
*((INSTR_OpCode*)myhreg) = put_value_p; //put_value Y1, A1
*((INSTR_EnvInd*)(myhreg + INSTR_ERX_E)) = 1;
*((INSTR_RegInd*)(myhreg + INSTR_ERX_R)) = 1;
myhreg += INSTR_ERX_LEN;
*((INSTR_OpCode*)myhreg) = put_level; //put_level Y2
*((INSTR_EnvInd*)(myhreg + INSTR_EX_E)) = 2;
myhreg += INSTR_EX_LEN;
*((INSTR_OpCode*)myhreg) = deallocate; //deallocate
myhreg += INSTR_X_LEN;
//solveCode
AM_solveCode = myhreg;
*((INSTR_OpCode*)myhreg) = builtin; //builtin BI_SOLVE
*((INSTR_OneByteInt*)(myhreg + INSTR_I1X_I1)) = BI_SOLVE;
myhreg += INSTR_I1X_LEN;
//proceed
AM_proceedCode = myhreg; //proceed
*((INSTR_OpCode*)myhreg) = proceed;
myhreg += INSTR_X_LEN;
//orCode
AM_orCode = myhreg;
*((INSTR_OpCode*)myhreg) = trust_me; //trust_me 1
*((INSTR_OneByteInt*)(myhreg + INSTR_I1WPX_I1)) = 1;
myhreg += INSTR_I1WPX_LEN;
*((INSTR_OpCode*)myhreg) = builtin; //builtin BI_SOLVE
*((INSTR_OneByteInt*)(myhreg + INSTR_I1X_I1)) = BI_SOLVE;
myhreg += INSTR_I1X_LEN;
//allcode
*((INSTR_OneByteInt*)(myhreg + INSTR_I1LX_I1)) = 0; //"call" 0 L
myhreg += INSTR_I1LX_LEN;
AM_allCode = myhreg;
*((INSTR_OpCode*)myhreg) = decr_universe; //decr_universe
myhreg += INSTR_X_LEN;
*((INSTR_OpCode*)myhreg) = deallocate; //deallocate
myhreg += INSTR_X_LEN;
*((INSTR_OpCode*)myhreg) = proceed; //proceed
myhreg += INSTR_X_LEN;
//stopCode
AM_stopCode = myhreg;
*((INSTR_OpCode*)myhreg) = stop; //stop
myhreg += INSTR_X_LEN;
//notCode2
AM_notCode2 = myhreg;
*((INSTR_OpCode*)myhreg) = trust_me; //trust_me 0
*((INSTR_OneByteInt*)(myhreg + INSTR_I1WPX_I1)) = 0;
myhreg += INSTR_I1WPX_LEN;
*((INSTR_OpCode*)myhreg) = proceed; //proceed
myhreg += INSTR_X_LEN;
//notCode1
AM_notCode1 = myhreg;
*((INSTR_OpCode*)myhreg) = allocate; //allocate 2
*((INSTR_OneByteInt*)(myhreg + INSTR_I1X_I1)) = 2;
myhreg += INSTR_I1X_LEN;
*((INSTR_OpCode*)myhreg) = get_level; //get_level Y1
*((INSTR_EnvInd*)(myhreg + INSTR_EX_E)) = 1;
myhreg += INSTR_EX_LEN;
*((INSTR_OpCode*)myhreg) = call_builtin; //call_builtin 1 BI_SOLVE
*((INSTR_OneByteInt*)(myhreg + INSTR_I1I1WPX_I11)) = 1;
*((INSTR_OneByteInt*)(myhreg + INSTR_I1I1WPX_I12)) = BI_SOLVE;
myhreg += INSTR_I1I1WPX_LEN;
*((INSTR_OpCode*)myhreg) = cut; //cut 1
*((INSTR_EnvInd*)(myhreg + INSTR_EX_E)) = 1;
myhreg += INSTR_EX_LEN;
*((INSTR_OpCode*)myhreg) = fail; //fail
myhreg += INSTR_X_LEN;
//haltCode
AM_haltCode = myhreg;
*((INSTR_OpCode*)myhreg) = halt; //halt
myhreg += INSTR_X_LEN;
AM_hreg = nhreg;
}
/*****************************************************************************
* THE PUBLIC ROUTINES *
*****************************************************************************/
void SINIT_preInit()
{
/* errors get initialized before ANYTHING */
MSG_addMessages(SIM_NUM_ERROR_MESSAGES, SIM_errorMessages);
}
void SINIT_simInit()
{
AM_hreg = AM_heapBeg; //heap
AM_hbreg = AM_heapBeg;
AM_ereg = AM_stackBeg; //stack
AM_ireg = AM_stackBeg;
AM_cireg = AM_stackBeg;
AM_initPDL(); //pdl
AM_trreg = AM_trailBeg; //trail
AM_llreg = DF_EMPTY_DIS_SET; //live list
AM_bndFlag = OFF; //bind flag
AM_ucreg = 0; //uc reg
//make a dummy first mod point at the beginning of the stack
AM_mkDummyImptRec(AM_ireg);
/* perform initialization for the term io system */
IO_initIO();
/* and set up some built-in code */
SINIT_initCode();
/* set up the base branch register to put the heap back to this point */
AM_breg = AM_stackBeg + AM_DUMMY_IMPT_REC_SIZE;
*AM_breg = (Mem)AM_hreg;
AM_fstCP = AM_b0reg = AM_breg;
AM_tosreg = AM_breg + 1;
}
void SINIT_reInitSimState(Boolean inDoInitializeImports)
{
AM_initPDL(); //pdl
AM_ereg = AM_stackBeg; //stack
AM_trreg = AM_trailBeg; //trail
AM_llreg = DF_EMPTY_DIS_SET; //live list
AM_ucreg = 0; //uc reg
AM_bndFlag = OFF; //bind flag
AM_breg = AM_fstCP;
AM_hreg = AM_cpH();
AM_hreg = *((MemPtr *)AM_breg);
/* initialize ireg if necessary */
if (inDoInitializeImports) {
AM_ireg = AM_stackBeg;
AM_tosreg = AM_breg + 1;
}
IO_initIO();
}
#endif //SIMINIT_H