amzi.h

这是个源码合集

/****************************************************************************

Amzi.h - C/C++ Logic Server API Interface


Copyright (c) 1992-2000 by Amzi! inc.  All Rights Reserved.

****************************************************************************/

#ifndef LOGIC_SERVER_DEFINED
#define LOGIC_SERVER_DEFINED

/* Environment dependent defines */
/* ----------------------------- */


/* Microsoft */

#ifdef _MSC_VER

#define MSC

#ifdef _WIN32
#define P32
#else
#define P16
#endif

#if defined(_WINDOWS) || defined(_WIN32)
#define MSWIN
#else
#define DOS
#endif

#endif // _MSC_VER

/* Borland */

#ifdef __BORLANDC__

#define BC

#ifdef __WIN32__
#define P32
#else
#define P16
#endif

#ifdef _Windows
#define MSWIN
#else
#define DOS
#endif

#endif // __BORLANDC__

/* Solaris */
#ifdef __sun
#define P32            /* 32-bit flat pointers */
#define UNIX
#define SOLARIS
#endif // __sun

/* DEC Alpha */

#ifdef __osf__
#define P64            /* 64-bit flat pointers */
#define UNIX
#endif

#ifdef __vms
#define P32            /* 32-bit flat pointers */
#define VMS
#endif

// Linux
// note that __unix__ is also defined
// as is __GNUC__, which may be of use someday

#ifdef __linux__
#define P32
#define UNIX
#define LINUX
#endif

#ifdef   UNIX
#include <ctype.h>
#endif

#ifdef _UNICODE
#ifdef   UNIX
#include <ctype.h>
#include <wchar.h>
#ifndef HPUX
#include <wctype.h>
#endif  // ndef HPUX
#endif  // UNIX
#endif  // _UNICODE

// commenting this out, maybe we can get away with it?
//#ifdef SOLARIS
//#include <widec.h>
//#endif

#ifdef _UNICODE
#define aCHAR wchar_t
#else
#define aCHAR char
#endif

/* Basic Types & Defines */

typedef   unsigned char  aBYTE;
typedef   char aSBYTE;

typedef   aBYTE *      aBYTEptr;
typedef   aSBYTE *     aSBYTEptr;

typedef  int   RC;          /* intended to be 0 for OK, else err no. */
#define  OK     0
#define  NOTOK  -1

typedef int TF;             /* intended for Prolog returns */
#define TRUE  1
#define FALSE 0

#ifdef BC
#define NULL   0
#endif

typedef   aCHAR  *    STRptr;
typedef   STRptr *    STRhnd;

typedef   void *      VOIDptr;
typedef   VOIDptr *   VOIDhnd;

/*   Amzi! integer sizes are often based on the size of a Prolog cell,
   which is the size of a pointer, which is 32-bits for most systems
   and 64-bits for others.  So, intC is a cell-sized integer, intCH
   a half cell, etc. */

#if defined(P64)

typedef long              intC;
typedef unsigned long    uintC;
typedef int              intCH;
typedef unsigned int    uintCH;
typedef short            intCQ;
typedef unsigned short  uintCQ;
typedef short            aINT16;
typedef unsigned short  UaINT16;
typedef int             aINT32;

#elif defined(P32)

typedef long              intC;
typedef unsigned long    uintC;
typedef short            intCH;
typedef unsigned short  uintCH;
typedef aSBYTE           intCQ;
typedef aBYTE           uintCQ;
typedef short            aINT16;
typedef unsigned short  UaINT16;
typedef long            aINT32;

#elif defined(P16)

typedef long              intC;
typedef unsigned long    uintC;
typedef short            intCH;
typedef unsigned short  uintCH;
typedef aSBYTE           intCQ;
typedef aBYTE           uintCQ;
typedef short            aINT16;
typedef unsigned short  UaINT16;
typedef long            aINT32;

#endif

typedef intC *        intCptr;
typedef intCH *       intCHptr;
typedef uintC *       uintCptr;

/* Various Prolog types */

typedef uintC      CELL;
typedef CELL *     CELLptr;

typedef CELLptr    TERM;
typedef TERM *     TERMptr;

typedef intCH      PATOM;             /* Prolog Atom */
typedef PATOM *    PATOMptr;

typedef uintCQ     ARITY;
typedef ARITY *    ARITYptr;

#ifdef BC  // Borland optimizes enums, so turn that feature off
#pragma option -b
#endif

typedef enum
{
   pERR = -1,
   pATOM,
   pINT,
   pSTR,
   pFLOAT,
   pSTRUCT,
   pLIST,
   pTERM,
   pADDR,
   pVAR,
   pWSTR,
   pWATOM
} pTYPE;

typedef enum
{
   cAATOM,
   cASTR,
   cINT,
   cLONG,
   cSHORT,
   cFLOAT,
   cDOUBLE,
   cADDR,
   cTERM,
   cWSTR,
   cWATOM
} cTYPE;

typedef enum
{
   CUR_IN,
   CUR_OUT,
   CUR_ERR,
   USER_IN,
   USER_OUT,
   USER_ERR
} STREAM;

// The exception types.
typedef enum
{
   BADENG,
#ifdef BC    // this anomaly was discovered too late to change all aborts
   LSABORT,
#else
   ABORT,
#endif
   INTERNAL,
   FATAL,
   INIT,
   API,
   LOAD,
   EXEC,
   READ,
   UNKNOWN
} ExType;

#ifdef BC  // enums done, turn them back on, (Thanks to Jorge Pelizzoni)
#pragma option -b.
#endif

#define STR_BUF 512

//typedef uintC   ENGid;
typedef void * ENGid;
typedef ENGid * ENGidptr;


/*   External function calling convention declarations */

#if defined(MSWIN) && defined(P16)
#define LSAPI __pascal
#define EXPFUNC __export __pascal
typedef TF (EXPFUNC *ExtPred)(VOIDptr);

#elif defined(MSWIN) && defined(P32)
#define LSAPI __stdcall
#define EXPFUNC __stdcall
typedef TF (EXPFUNC *ExtPred)(VOIDptr);

#elif defined(DOS)
#define LSAPI __pascal
#define EXPFUNC __pascal
typedef TF (EXPFUNC *ExtPred)(VOIDptr);

#else
#define LSAPI
#define EXPFUNC
typedef TF (*ExtPred)(VOIDptr);

#endif

/*   External I/O functions used in callbacks. */

#define lsCALLTYPE LSAPI

/*   Note that these functions expect Unicode characters
   in both the strings and ints.  For ANSI characters,
   the ints can simply be cast, but for the string in
   puts the routine mbstowcs() can be used to convert
   an ASNI string to a wide Unicode string. */
typedef int  (lsCALLTYPE *pX_GETC)(VOIDptr);
typedef int  (lsCALLTYPE *pX_UNGETC)(VOIDptr, int);
typedef int  (lsCALLTYPE *pX_PUTC)(VOIDptr, int);
typedef int  (lsCALLTYPE *pX_PUTSA)(VOIDptr, char*);
#ifdef _UNICODE
typedef int  (lsCALLTYPE *pX_PUTSW)(VOIDptr, wchar_t*);
#endif

/*   Structure used to hold mappings between
   extended Prolog predicate names and the
   functions that implement them. */

#ifdef _UNICODE
typedef struct {
     wchar_t*   Pname;
     ARITY      Parity;
     ExtPred    Pfunc;
} PRED_INITW;
typedef PRED_INITW * PRED_INITWptr;
#endif

typedef struct {
     char*      Pname;
     ARITY      Parity;
     ExtPred    Pfunc;
} PRED_INITA;
typedef PRED_INITA * PRED_INITAptr;


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

#ifdef _UNICODE

#define cSTR cWSTR
#define cATOM cWATOM
#define lsInit lsInitW
#define lsInit2 lsInit2W
#define lsAddLSX lsAddLSXW
#define lsAddPred lsAddPredW
#define PRED_INIT PRED_INITW
#define PRED_INITptr PRED_INITWptr
#define lsInitPreds lsInitPredsW
#define lsLoad lsLoadW
#define lsExecStr lsExecStrW
#define lsCallStr lsCallStrW
#define lsAssertaStr lsAssertaStrW
#define lsAssertzStr lsAssertzStrW
#define lsRetractStr lsRetractStrW
#define lsTermToStr lsTermToStrW
#define lsTermToStrQ lsTermToStrQW
#define lsStrToTerm lsStrToTermW
#define lsMakeAtom lsMakeAtomW
#define lsMakeStr lsMakeStrW
#define lsGetFA lsGetFAW
#define lsMakeFA lsMakeFAW
#define lsGetVersion lsGetVersionW
#define lsSetCommandArgs lsSetCommandArgsW
#define lsErrRaise lsErrRaiseW
#define lsGetExceptMsg lsGetExceptMsgW
#define lsGetExceptReadBuffer lsGetExceptReadBufferW
#define lsGetExceptReadFileName lsGetExceptReadFileNameW
#define lsGetExceptCallStack lsGetExceptCallStackW
#define pX_PUTS pX_PUTSW
#define lsSetOutput lsSetOutputW
#else

#define cSTR cASTR
#define cATOM cAATOM
#define lsInit lsInitA
#define lsInit2 lsInit2A
#define lsAddLSX lsAddLSXA
#define lsAddPred lsAddPredA
#define PRED_INIT PRED_INITA
#define PRED_INITptr PRED_INITAptr
#define lsInitPreds lsInitPredsA
#define lsLoad lsLoadA
#define lsExecStr lsExecStrA
#define lsCallStr lsCallStrA
#define lsAssertaStr lsAssertaStrA
#define lsAssertzStr lsAssertzStrA
#define lsRetractStr lsRetractStrA
#define lsTermToStr lsTermToStrA
#define lsTermToStrQ lsTermToStrQA
#define lsStrToTerm lsStrToTermA
#define lsMakeAtom lsMakeAtomA
#define lsMakeStr lsMakeStrA
#define lsGetFA lsGetFAA
#define lsMakeFA lsMakeFAA
#define lsGetVersion lsGetVersionA
#define lsSetCommandArgs lsSetCommandArgsA
#define lsErrRaise lsErrRaiseA
#define lsGetExceptMsg lsGetExceptMsgA
#define lsGetExceptReadBuffer lsGetExceptReadBufferA
#define lsGetExceptReadFileName lsGetExceptReadFileNameA
#define lsGetExceptCallStack lsGetExceptCallStackA
#define pX_PUTS pX_PUTSA
#define lsSetOutput lsSetOutputA
#endif //_UNICODE

#ifdef __cplusplus
extern "C"
{
#endif

/* Main entry points to set up Prolog environment */

RC  LSAPI  lsInitA(ENGidptr, char*);
RC  LSAPI  lsInit2A(ENGidptr, char*);
RC  LSAPI  lsInitLSX(ENGid, VOIDptr);
RC  LSAPI  lsAddLSXA(ENGid, char*, VOIDptr);
RC  LSAPI  lsAddPredA(ENGid, char*, ARITY, ExtPred, VOIDptr);
RC  LSAPI  lsInitPredsA(ENGid, PRED_INITAptr);
RC  LSAPI  lsLoadA(ENGid, char*);
TF  LSAPI  lsMain(ENGid);
RC  LSAPI  lsReset(ENGid);
RC  LSAPI  lsClose(ENGid);

/* function and predicate parameters */

RC    LSAPI  lsGetParm(ENGid, int, cTYPE, VOIDptr);
pTYPE LSAPI  lsGetParmType(ENGid, int);
int   LSAPI  lsStrParmLen(ENGid, int);
TF    LSAPI  lsUnifyParm(ENGid, int, cTYPE, VOIDptr);

/* Calling Prolog from C */

TF LSAPI  lsExec(ENGid, TERMptr);
TF LSAPI  lsExecStrA(ENGid, TERMptr, char*);
TF LSAPI  lsCall(ENGid, TERMptr);
TF LSAPI  lsCallStrA(ENGid, TERMptr, char*);
TF LSAPI  lsRedo(ENGid);
RC LSAPI  lsClearCall(ENGid);

/* Asserting and retracting */

RC LSAPI  lsAsserta(ENGid, TERM);
RC LSAPI  lsAssertz(ENGid, TERM);
TF LSAPI  lsRetract(ENGid, TERM);
RC LSAPI  lsAssertaStrA(ENGid, char*);
RC LSAPI  lsAssertzStrA(ENGid, char*);
TF LSAPI  lsRetractStrA(ENGid, char*);


/* String/Term conversion functions */

RC LSAPI  lsTermToStrA(ENGid, TERM, char*, int);
RC LSAPI  lsTermToStrQA(ENGid, TERM, char*, int);
RC LSAPI  lsStrToTermA(ENGid, TERMptr, char*);

/* Making Prolog types */

RC LSAPI  lsMakeAtomA(ENGid, TERMptr, char*);
RC LSAPI  lsMakeStrA(ENGid, TERMptr, char*);
RC LSAPI  lsMakeInt(ENGid, TERMptr, intC);
RC LSAPI  lsMakeFloat(ENGid, TERMptr, double);
RC LSAPI  lsMakeAddr(ENGid, TERMptr, VOIDptr);

/* Getting C values from Prolog terms */

pTYPE LSAPI  lsGetTermType(ENGid, TERM);
RC    LSAPI  lsGetTerm(ENGid, TERM, cTYPE, VOIDptr);
int   LSAPI  lsStrTermLen(ENGid, TERM);

/* Structure hacking functions */

RC  LSAPI  lsGetFAA(ENGid, TERM, char*, ARITYptr);
RC  LSAPI  lsMakeFAA(ENGid, TERMptr, char*, ARITY);
TF  LSAPI  lsUnifyArg(ENGid, TERMptr, int, cTYPE, VOIDptr);
RC  LSAPI  lsGetArg(ENGid, TERM, int, cTYPE, VOIDptr);
pTYPE LSAPI  lsGetArgType(ENGid, TERM, int);
int LSAPI  lsStrArgLen(ENGid, TERM, int);
TF  LSAPI  lsUnify(ENGid, TERM, TERM);

/* List hacking functions */

RC LSAPI  lsMakeList(ENGid, TERMptr);
RC LSAPI  lsPushList(ENGid, TERMptr, TERM);
RC LSAPI  lsPopList(ENGid, TERMptr, cTYPE, VOIDptr);
RC LSAPI  lsGetHead(ENGid, TERM, cTYPE, VOIDptr);
TERM LSAPI  lsGetTail(ENGid, TERM);

/* Stream I/O functions */

RC  LSAPI  lsSetStream(ENGid, STREAM, int);
int LSAPI  lsGetStream(ENGid, STREAM);

RC  LSAPI  lsSetInput(ENGid, pX_GETC, pX_UNGETC);
RC  LSAPI  lsSetOutputA(ENGid, pX_PUTC, pX_PUTSA);
RC  LSAPI  lsSetIOArg(ENGid, VOIDptr);
RC  LSAPI  lsWinIO(ENGid, int(*)(), int(*)(),
                           int(*)(), int(*)(), int(*)() );

/* Miscellaneous functions */

RC  LSAPI  lsGetVersionA(ENGid, char*);
RC  LSAPI  lsSetCommandArgsA(ENGid, int, char**);
RC  LSAPI  lsSetAllocFree(ENGid, VOIDptr(*)(), void(*)());

/* Error handling */

RC LSAPI  lsErrRaiseA(ENGid, char*);

ExType LSAPI  lsGetExceptType(ENGid);
RC     LSAPI  lsGetExceptRC(ENGid);
intC   LSAPI  lsGetExceptLineno(ENGid);
void   LSAPI  lsGetExceptMsgA(ENGid, char*, int);
void   LSAPI  lsGetExceptReadFileNameA(ENGid, char*, int);
void   LSAPI  lsGetExceptReadBufferA(ENGid, char*, int);
void   LSAPI  lsGetExceptCallStackA(ENGid, char*, int);

#ifdef _UNICODE
RC  LSAPI  lsInitW(ENGidptr, wchar_t*);
RC  LSAPI  lsInit2W(ENGidptr, wchar_t*);
RC  LSAPI  lsAddLSXW(ENGid, wchar_t*, VOIDptr);
RC  LSAPI  lsAddPredW(ENGid, wchar_t*, ARITY, ExtPred, VOIDptr);
RC  LSAPI  lsInitPredsW(ENGid, PRED_INITWptr);
RC  LSAPI  lsLoadW(ENGid, wchar_t*);
TF LSAPI  lsExecStrW(ENGid, TERMptr, wchar_t*);
TF LSAPI  lsCallStrW(ENGid, TERMptr, wchar_t*);