amzi.h

这是个源码合集

RC LSAPI  lsAssertaStrW(ENGid, wchar_t*);
RC LSAPI  lsAssertzStrW(ENGid, wchar_t*);
TF LSAPI  lsRetractStrW(ENGid, wchar_t*);
RC LSAPI  lsTermToStrW(ENGid, TERM, wchar_t*, int);
RC LSAPI  lsTermToStrQW(ENGid, TERM, wchar_t*, int);
RC LSAPI  lsStrToTermW(ENGid, TERMptr, wchar_t*);
RC LSAPI  lsMakeAtomW(ENGid, TERMptr, wchar_t*);
RC LSAPI  lsMakeStrW(ENGid, TERMptr, wchar_t*);
RC  LSAPI  lsGetFAW(ENGid, TERM, wchar_t*, ARITYptr);
RC  LSAPI  lsMakeFAW(ENGid, TERMptr, wchar_t*, ARITY);
RC  LSAPI  lsSetOutputW(ENGid, pX_PUTC, pX_PUTSW);
RC  LSAPI  lsGetVersionW(ENGid, wchar_t*);
RC  LSAPI  lsSetCommandArgsW(ENGid, int, wchar_t**);
RC LSAPI  lsErrRaiseW(ENGid, wchar_t*);
void   LSAPI  lsGetExceptMsgW(ENGid, wchar_t*, int);
void   LSAPI  lsGetExceptReadFileNameW(ENGid, wchar_t*, int);
void   LSAPI  lsGetExceptReadBufferW(ENGid, wchar_t*, int);
void   LSAPI  lsGetExceptCallStackW(ENGid, wchar_t*, int);
#endif

#ifdef __cplusplus
}
#endif


/* C++ Logic Server API (LSAPI) Class Interface */
/* -------------------------------------------- */

// The CLogicServer class is provided for VC++ as part of
// the amzi DLL.  For other C++ environments, it is
// provided as a wrapper on the functional LSAPI above.

#ifdef __cplusplus

#ifdef MSC

class LEngine;
class LExcept;
class CLogicServer;

typedef TF (EXPFUNC *ExtDispPred)(CLogicServer*);

class CLogicServer
{
private:
   LEngine *m_peng;
   RC       m_rc;

public:
// Constructors and Destructor

   CLogicServer();
   CLogicServer(aCHAR * xplname);
   virtual ~CLogicServer();

// Main entry points to set up Prolog environment

   void   Init(aCHAR * ininame);
   void   Init2(aCHAR * inistring);
   void   InitLSX(void * vp);
   void   InitLSX();
   void   AddLSX(aCHAR* s, void * vp);
   void   AddLSX(aCHAR* s);
   void   AddPred(aCHAR* s, ARITY a, ExtPred f, VOIDptr v);
   void   InitPreds(PRED_INITptr preds);
   void   Load(aCHAR *lsprog);
   TF     Main(void);
   void   Reset(void);
   void   Close(void);

// function and predicate parameters

   void   GetParm(int i, cTYPE ct, void * vp);
   pTYPE  GetParmType(int i);
   int    StrParmLen(int i);
   TF     UnifyParm(int i, cTYPE ct, VOIDptr vp);

// Calling Prolog from C

   TF     Exec(TERMptr tp);
   TF     ExecStr(TERMptr tp, aCHAR* s);
   TF     Call(TERMptr tp);
   TF     CallStr(TERMptr tp, aCHAR* s);
   TF     Redo(void);
   TF     ClearCall(void);

// Asserting and retracting

   void   Asserta(TERM t);
   void   Assertz(TERM t);
   TF     Retract(TERM t);
   void   AssertaStr(aCHAR* s);
   void   AssertzStr(aCHAR* s);
   TF     RetractStr(aCHAR* s);

// String/Term conversion functions

   void   TermToStr(TERM t, aCHAR* s, int i);
   void   TermToStrQ(TERM t, aCHAR* s, int i);
   void   StrToTerm(TERMptr tp, aCHAR* s);

// Making Prolog types

   void   MakeAtom(TERMptr tp, aCHAR* s);
   void   MakeStr(TERMptr tp, aCHAR* s);
   void   MakeInt(TERMptr tp, intC i);
   void   MakeFloat(TERMptr tp, double f);
   void   MakeAddr(TERMptr tp, VOIDptr vp);

// Getting C values from Prolog terms

   pTYPE  GetTermType(TERM t);
   void   GetTerm(TERM t, cTYPE ct, VOIDptr vp);
   int    StrTermLen(TERM t);

// Structure hacking functions

   void   GetFA(TERM t, aCHAR* s, ARITYptr ap);
   void   MakeFA(TERMptr tp, aCHAR* s, ARITY a);
   TF     UnifyArg(TERMptr tp, int i, cTYPE ct, VOIDptr vp);
   void   GetArg(TERM t, int i, cTYPE ct, VOIDptr vp);
   pTYPE  GetArgType(TERM t, int i);
   int    StrArgLen(TERM t, int i);
   TF     Unify(TERM t1, TERM t2);

// List hacking functions

   void   MakeList(TERMptr tp);
   void   PushList(TERMptr tp, TERM t);
   RC     PopList(TERMptr tp, cTYPE ct, VOIDptr vp);
   RC     GetHead(TERM t, cTYPE ct, VOIDptr vp);
   TERM   GetTail(TERM t);

// Stream I/O functions

   void   SetStream(STREAM st, int i);
   int    GetStream(STREAM st);
   void   SetInput(pX_GETC, pX_UNGETC);
   void   SetOutput(pX_PUTC, pX_PUTS);
   void   SetIOArg(VOIDptr);

// Miscellaneous functions

   void   GetVersion(aCHAR* s);
   void   SetCommandArgs(int pargc, aCHAR** pargv);

   void   ErrRaise(aCHAR* s);

// Single byte character string equivalents of
// functions with Unicode arguments.

#ifdef _UNICODE
   CLogicServer(char * xplname);
   void   Init(char * ininame);
   void   Init2(char * inistring);
   void   AddLSX(char* s, void * vp);
   void   AddLSX(char* s);
   void   AddPred(char* s, ARITY a, ExtPred f, VOIDptr v);
   void   InitPreds(PRED_INITAptr preds);
   void   Load(char *lsprog);
   TF     ExecStr(TERMptr tp, char* s);
   TF     CallStr(TERMptr tp, char* s);
   void   AssertaStr(char* s);
   void   AssertzStr(char* s);
   TF     RetractStr(char* s);
   void   TermToStr(TERM t, char* s, int i);
   void   TermToStrQ(TERM t, char* s, int i);
   void   StrToTerm(TERMptr tp, char* s);
   void   MakeAtom(TERMptr tp, char* s);
   void   MakeStr(TERMptr tp, char* s);
   void   GetFA(TERM t, char* s, ARITYptr ap);
   void   MakeFA(TERMptr tp, char* s, ARITY a);
   void   SetOutput(pX_PUTC, pX_PUTSA);
   void   GetVersion(char* s);
   void   SetCommandArgs(int pargc, char** pargv);
   void   ErrRaise(char* s);
#endif // _UNICODE
};

const int MSGLEN = 120;

class CLSException
{
private:
   LExcept  *m_px;

public:
   CLSException(LExcept &ex);
   CLSException(CLSException &lsex);
   virtual ~CLSException();
   int GetRC();
   ExType GetType();
   intC GetReadLineno();
   void GetMsg(aCHAR*, int);
   void GetReadBuffer(aCHAR*, int);
   void GetReadFileName(aCHAR*, int);
   void GetCallStack(aCHAR*, int);
#ifdef _UNICODE
   void GetMsg(char*, int);
   void GetReadBuffer(char*, int);
   void GetReadFileName(char*, int);
   void GetCallStack(char*, int);
#endif /* _UNICODE */
};

#else /* end MSC section */

// An external C++ wrapper on the functional LSAPI
// for environments that cannot directly access
// the exported C++ CLogicServer class.

class CLogicServer
{
private:
   ENGid    m_eng;

public:

// Constructors and Destructor

   CLogicServer();
   CLogicServer(aCHAR * xplname);
   virtual ~CLogicServer();

// Main entry points to set up Prolog environment

   void   Init(aCHAR * ininame);
   void   Init2(aCHAR * inistring);
   void   InitLSX(void * vp);
   void   InitLSX();
   void   AddLSX(aCHAR* s, void * vp);
   void   AddLSX(aCHAR* s);
   void   AddPred(aCHAR* s, ARITY a, ExtPred f, VOIDptr v);
   //void   AddDispatchPred(aCHAR* s, ARITY a, ExtDispPred f);
   void   InitPreds(PRED_INITptr preds);
   void   Load(aCHAR *lsprog);
   TF     Main(void);
   void   Reset(void);
   void   Close(void);

// function and predicate parameters

   void   GetParm(int i, cTYPE ct, void * vp);
   pTYPE  GetParmType(int i);
   int    StrParmLen(int i);
   TF     UnifyParm(int i, cTYPE ct, VOIDptr vp);

// Calling Prolog from C

   TF     Exec(TERMptr tp);
   TF     ExecStr(TERMptr tp, aCHAR* s);
   TF     Call(TERMptr tp);
   TF     CallStr(TERMptr tp, aCHAR* s);
   TF     Redo(void);
   TF     ClearCall(void);

// Asserting and retracting

   void   Asserta(TERM t);
   void   Assertz(TERM t);
   TF     Retract(TERM t);
   void   AssertaStr(aCHAR* s);
   void   AssertzStr(aCHAR* s);
   TF     RetractStr(aCHAR* s);

// String/Term conversion functions

   void   TermToStr(TERM t, aCHAR* s, int i);
   void   TermToStrQ(TERM t, aCHAR* s, int i);
   void   StrToTerm(TERMptr tp, aCHAR* s);

// Making Prolog types

   void   MakeAtom(TERMptr tp, aCHAR* s);
   void   MakeStr(TERMptr tp, aCHAR* s);
   void   MakeInt(TERMptr tp, intC i);
   void   MakeFloat(TERMptr tp, double f);
   void   MakeAddr(TERMptr tp, VOIDptr vp);

// Getting C values from Prolog terms

   pTYPE  GetTermType(TERM t);
   void   GetTerm(TERM t, cTYPE ct, VOIDptr vp);
   int    StrTermLen(TERM t);

// Structure hacking functions

   void   GetFA(TERM t, aCHAR* s, ARITYptr ap);
   void   MakeFA(TERMptr tp, aCHAR* s, ARITY a);
   TF     UnifyArg(TERMptr tp, int i, cTYPE ct, VOIDptr vp);
   void   GetArg(TERM t, int i, cTYPE ct, VOIDptr vp);
   pTYPE  GetArgType(TERM t, int i);
   int    StrArgLen(TERM t, int i);
   TF     Unify(TERM t1, TERM t2);

// List hacking functions

   void   MakeList(TERMptr tp);
   void   PushList(TERMptr tp, TERM t);
   RC     PopList(TERMptr tp, cTYPE ct, VOIDptr vp);
   RC     GetHead(TERM t, cTYPE ct, VOIDptr vp);
   TERM   GetTail(TERM t);

// Stream I/O functions

   void   SetStream(STREAM st, int i);
   int    GetStream(STREAM st);
   void   SetInput(pX_GETC fgetc, pX_UNGETC funget);
   void   SetOutput(pX_PUTC fputc, pX_PUTS fputs);
   void   SetIOArg(VOIDptr vp);

// Miscellaneous functions

   void   GetVersion(aCHAR* s);
   void   SetCommandArgs(int pargc, aCHAR** pargv);

   void   ErrRaise(aCHAR* s);

// For Unicode build, here are single byte equivalents
#ifdef _UNICODE
   CLogicServer(char * xplname);
   void   Init(char * ininame);
   void   Init2(char * inistring);
   void   InitPreds(PRED_INITAptr preds);
   void   AddLSX(char* s, void * vp);
   void   AddLSX(char* s);
   void   AddPred(char* s, ARITY a, ExtPred f, VOIDptr v);
   void   Load(char *lsprog);
   TF     ExecStr(TERMptr tp, char* s);
   TF     CallStr(TERMptr tp, char* s);
   void   AssertaStr(char* s);
   void   AssertzStr(char* s);
   TF     RetractStr(char* s);
   void   TermToStr(TERM t, char* s, int i);
   void   TermToStrQ(TERM t, char* s, int i);
   void   StrToTerm(TERMptr tp, char* s);
   void   MakeAtom(TERMptr tp, char* s);
   void   MakeStr(TERMptr tp, char* s);
   void   GetFA(TERM t, char* s, ARITYptr ap);
   void   MakeFA(TERMptr tp, char* s, ARITY a);
   void   SetOutput(pX_PUTC fputc, pX_PUTSA fputs);
   void   GetVersion(char* s);
   void   SetCommandArgs(int pargc, char** pargv);
   void   ErrRaise(char* s);

#endif
};

class CLSException
{
private:
   ENGid m_eng;

public:
   CLSException(ENGid e) { m_eng = e; }
   CLSException(const CLSException &e)
   {   m_eng = e.m_eng; }
   virtual ~CLSException() {};
   int GetRC();
   void GetMsg(aCHAR*, int);
   ExType GetType();
   void GetReadFileName(aCHAR*, int);
   void GetReadBuffer(aCHAR*, int);
   void GetCallStack(aCHAR*, int);
   intC GetReadLineno();
#ifdef _UNICODE
   void GetMsg(char*, int);
   void GetReadFileName(char*, int);
   void GetReadBuffer(char*, int);
   void GetCallStack(char*, int);
#endif // _UNICODE
};

/*----------------------------------------*/
/*  External CLogicServer implementation  */
/*                                        */

inline CLogicServer::CLogicServer()
{
   m_eng = NULL;
}

inline CLogicServer::CLogicServer(aCHAR* xplfile)
{
   Init(xplfile);
   Load(xplfile);
}

inline CLogicServer::~CLogicServer()
{
   //Close();
}

inline void CLogicServer::Init(aCHAR* ininame)
{
   RC rc = lsInit(&m_eng, ininame);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::Init2(aCHAR* inistring)
{
   RC rc = lsInit2(&m_eng, inistring);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::InitLSX(void * vp)
{
   RC rc = lsInitLSX(m_eng, vp);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::InitLSX()
{
   RC rc = lsInitLSX(m_eng, NULL);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::AddLSX(aCHAR* s, void * vp)
{
   RC rc = lsAddLSX(m_eng, s, vp);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::AddLSX(aCHAR* s)
{
   RC rc = lsAddLSX(m_eng, s, NULL);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::AddPred(aCHAR* s, ARITY a, ExtPred f, VOIDptr v)
{
   RC rc = lsAddPred(m_eng, s, a, f, v);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::InitPreds(PRED_INITptr preds)
{
   RC rc = lsInitPreds(m_eng, preds);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::Load(aCHAR* xplname)
{
   RC rc = lsLoad(m_eng, xplname);
   if (rc) throw CLSException(m_eng);
}

inline TF CLogicServer::Main(void)
{
   TF tf = lsMain(m_eng);
   if (tf != TRUE && tf != FALSE)
      throw CLSException(m_eng);
   return tf;
}

inline void CLogicServer::Reset(void)
{
   RC rc = lsReset(m_eng);
   if (rc) throw CLSException(m_eng);
}

inline void CLogicServer::Close(void)
{
   RC rc = lsClose(m_eng);
   if (rc) throw CLSException(m_eng);
}


// function and predicate parameters

inline void CLogicServer::GetParm(int i, cTYPE ct, void * vp)
{
   RC rc = lsGetParm(m_eng, i, ct, vp);
   if (rc) throw CLSException(m_eng);
}

inline pTYPE CLogicServer::GetParmType(int i)
{
    pTYPE pT = lsGetParmType(m_eng, i);
   if (pT == pERR)
      throw CLSException(m_eng);
   return pT;
}

inline int CLogicServer::StrParmLen(int i)
{
   int len = lsStrParmLen(m_eng, i);
   if (len == NOTOK)
      throw CLSException(m_eng);
   return len;
}

inline TF CLogicServer::UnifyParm(int i, cTYPE ct, VOIDptr vp)
{
   TF tf = lsUnifyParm(m_eng, i, ct, vp);
   if (tf != TRUE && tf != FALSE)
      throw CLSException(m_eng);
   return tf;
}


// Calling Prolog from C

inline TF CLogicServer::Exec(TERMptr tp)
{
   TF tf = lsExec(m_eng, tp);
   if (tf != TRUE && tf != FALSE)
      throw CLSException(m_eng);
   return tf;
}

inline TF CLogicServer::ExecStr(TERMptr tp, aCHAR* s)
{
   TF tf = lsExecStr(m_eng, tp, s);
   if (tf != TRUE && tf != FALSE)
      throw CLSException(m_eng);
   return tf;
}

inline TF CLogicServer::Call(TERMptr tp)
{
   TF tf = lsCall(m_eng, tp);
   if (tf != TRUE && tf != FALSE)
      throw CLSException(m_eng);
   return tf;