YapDefs.h

/*************************************************************************
 *                                   *
 *   YAP Prolog     @(#)c_interface.h   2.2          *
 *  Yap Prolog was developed at NCCUP - Universidade do Porto    *
 *                                   *
 * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997  *
 *                                   *
 **************************************************************************
 *                                   *
 * File:        yap_structs.h *
 * Last rev:    15/5/2000                        *
 * mods: *
 * comments:    Data structures and defines used in the Interface    *
 *                                   *
 *************************************************************************/
 
#ifndef _YAPDEFS_H
 
#define _YAPDEFS_H 1
 
#include "YapConfig.h"
#if HAVE_SETJMP_H
#include <setjmp.h>
#endif
 
#if _WIN32
#if defined(_EXPORT_KERNEL)
// __declspec(dllexport)
#define X_API
#else
// __declspec(dllimport)
#define X_API
#endif
// __declspec(dllexport)
#define O_API
// __declspec(dllimport)
#define I_API
#else
#define O_API
#define I_API
#define X_API
#endif
 
#include <stdio.h>
#include <stdlib.h>
 
/* The YAP main types */
#include "YapTerm.h"
 
#if HAVE_STDINT_H
#include <stdint.h>
#endif
#if HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#if HAVE_NORETURNSTD_H
#include <noreturnstd.h>
#endif
 
#ifndef TRUE
#define TRUE true
#endif
#ifndef FALSE
#define FALSE false
#endif
#ifndef YAP_Bool
typedef bool YAP_Bool;
#endif
 
#define TermZERO ((Term)0)
 
 
typedef void *YAP_PredEntryPtr;
 
typedef size_t YAP_Arity;
 
typedef YAP_Term YAP_Module;
 
typedef YAP_Int YAP_handle_t;
 
typedef void *YAP_PredEntryPtr;
 
typedef YAP_Bool (*YAP_UserCPred)(void);
 
typedef int (*YAP_agc_hook)(void *_Atom);
 
#include "YapError.h"
 
#include "../os/encoding.h"
 
typedef encoding_t YAP_encoding_t;
 
#if __ANDROID__
#include <android/asset_manager.h>
#include <android/native_activity.h>
#endif
 
typedef struct YAP_thread_attr_struct {
  size_t ssize;
  size_t tsize;
  size_t sysize;
  int (*cancel)(int thread);
  YAP_Term egoal, alias;
} YAP_thread_attr;
 
#ifdef YAP_H
#include <threads.h>
 
#endif
 
typedef enum {
YAP_OBJ = 0x0008,
        YAP_PL = 0x0010,
        YAP_SOURCE_PL = 0x0030,
        YAP_QLY = 0x0040,
        YAP_EXE = 0x0080,
        YAP_FOUND_BOOT_ERROR = 0x0100,
        YAP_DIR = 0x0200
} YAP_file_type_t;
 
 
#define YAP_ANY_FILE (0x00ff)
 
typedef enum {
  YAP_TAG_ATT = 0x1,
  YAP_TAG_UNBOUND = 0x2,
  YAP_TAG_REF = 0x4,
  YAP_TAG_PAIR = 0x8,
  YAP_TAG_ATOM = 0x10,
  YAP_TAG_INT = 0x20,
  YAP_TAG_LONG_INT = 0x40,
  YAP_TAG_BIG_INT = 0x80,
  YAP_TAG_RATIONAL = 0x100,
  YAP_TAG_FLOAT = 0x200,
  YAP_TAG_OPAQUE = 0x400,
  YAP_TAG_APPL = 0x800,
  YAP_TAG_DBREF = 0x1000,
  YAP_TAG_STRING = 0x2000,
  YAP_TAG_ARRAY = 0x4000
} YAP_tag_t;
#define YAP_BOOT_FROM_SAVED_CODE 1
#define YAP_BOOT_FROM_SAVED_STACKS 2
#define YAP_BOOT_ERROR -1
 
#define YAP_WRITE_QUOTED 1
#define YAP_WRITE_IGNORE_OPS 2
#define YAP_WRITE_HANDLE_VARS 4
#define YAP_WRITE_USE_PORTRAY 8
#define YAP_WRITE_HANDLE_CYCLES 0x20
#define YAP_WRITE_BACKQUOTE_STRING 0x80
#define YAP_WRITE_ATTVAR_NONE 0x100
#define YAP_WRITE_ATTVAR_DOTS 0x200
#define YAP_WRITE_ATTVAR_PORTRAY 0x400
#define YAP_WRITE_BLOB_PORTRAY 0x800
 
#define YAP_CONSULT_MODE 0
#define YAP_RECONSULT_MODE 1
#define YAP_BOOT_MODE 2
 
X_API YAP_file_type_t Yap_InitDefaults(void *init_args, char saved_state[],
                                       int Argc, char *Argv[]);
 
#include  "YapInit.h"
 
 
/* this should be opaque to the user */
typedef struct {
    unsigned long b0;      //> choice-point before entry
    unsigned long b_entry;      //> choice-point at entry
    unsigned long b_exit;      //> choice-point at exit
    unsigned long env0;      //>environment at entry
    unsigned long h;      //>  HR at entry
    unsigned long tr;      //> TR at entry
  YAP_handle_t CurSlot; //> variables at entry
  YAP_handle_t EndSlot; //> variables at successful execution
  struct yami *p;       //> Program Counter at entry
  struct yami *cp;      //> Continuation PC at entry
  int lvl;              //> Memory allocator.
} YAP_dogoalinfo;
 
// query manipulation support
 
typedef struct open_query_struct {
  int q_open;
  int q_state;
  YAP_handle_t q_g;
  struct pred_entry *q_pe;
  struct yami *q_p, *q_cp;
  jmp_buf q_env;
  int q_flags;
  YAP_dogoalinfo q_h;
  struct open_query_struct *oq;
} YAP_openQuery;
 
typedef void (*YAP_halt_hook)(int exit_code, void *closure);
 
/* each type has a tag */
typedef YAP_Int YAP_opaque_tag_t;
 
typedef YAP_Bool (*YAP_Opaque_CallOnFail)(YAP_Term);
typedef YAP_Bool (*YAP_Opaque_CallOnCut)(YAP_Term);
typedef YAP_Bool (*YAP_Opaque_CallOnWrite)(FILE *, YAP_opaque_tag_t, void *,
                                           int);
typedef YAP_Int (*YAP_Opaque_CallOnGCMark)(YAP_opaque_tag_t, void *, YAP_Term *,
                                           YAP_Int);
typedef YAP_Bool (*YAP_Opaque_CallOnGCRelocate)(YAP_opaque_tag_t, void *,
                                                YAP_Term *, YAP_Int);
typedef struct YAP_opaque_handler_struct {
  YAP_Opaque_CallOnCut cut_handler; //< called at cut, which may be a forward
                                    // cut or an exception.
  YAP_Opaque_CallOnFail
      fail_handler; //< called at exit, it can be used to cleanup resources
  YAP_Opaque_CallOnWrite write_handler; //< text representation
  YAP_Opaque_CallOnGCMark
      mark_handler; //< useful if you include pointers to stack
  YAP_Opaque_CallOnGCRelocate
      relocate_handler; //< useful if you include pointers to stack
} YAP_opaque_handler_t;
 
extern YAP_Opaque_CallOnWrite Yap_blob_write_handler_from_slot(YAP_Int slot);
extern YAP_Opaque_CallOnGCMark Yap_blob_gc_mark_handler(YAP_Term t);
extern YAP_Opaque_CallOnGCRelocate Yap_blob_gc_relocate_handler(YAP_Term t);
extern YAP_Int Yap_blob_tag_from_slot(YAP_Int slot);
extern void *Yap_blob_info_from_slot(YAP_Int slot);
 
/********* execution mode ***********************/
 
 
/*************************************************************************************************
                                   Prolog may be in several modes
*************************************************************************************************/
 
typedef enum {
    BootMode = 0x1,            
    UserMode = 0x2,            
    CritMode = 0x4,            
    AbortMode = 0x8,           
    InterruptMode = 0x10,      /*8 under an interrupt */
    InErrorMode = 0x20,        
    ConsoleGetcMode = 0x40,    
    ExtendStackMode = 0x80,    
    GrowHeapMode = 0x100,      
    GrowStackMode = 0x200,     
    GCMode = 0x400,            
    ErrorHandlingMode = 0x800, 
    CCallMode = 0x1000,        
    UnifyMode = 0x2000,        
    UserCCallMode = 0x4000,    
    MallocMode = 0x8000,       
    SystemMode = 0x10000,      
    AsyncIntMode = 0x20000, 
    InReadlineMode =
    0x40000,          
    TopGoalMode = 0x40000 
} prolog_exec_mode;
 
typedef enum {
  YAPC_INTERPRETED,     /* interpreted */
  YAPC_MIXED_MODE_USER, /* mixed mode only for user predicates */
  YAPC_MIXED_MODE_ALL,  /* mixed mode for all predicates */
  YAPC_COMPILE_USER,    /* compile all user predicates*/
  YAPC_COMPILE_ALL      /* compile all predicates */
} execution_t;
 
 
typedef enum stream_f {
    Free_Stream_f = 0x000001,   
    Input_Stream_f = 0x000002,  
    Output_Stream_f = 0x000004, 
    Append_Stream_f = 0x000008, 
    Eof_Stream_f = 0x000010,    
    Null_Stream_f = 0x000020,   
    Tty_Stream_f = 0x000040,    
    Socket_Stream_f = 0x000080, 
    Binary_Stream_f = 0x000100, 
    Eof_Error_Stream_f =
    0x000200, 
    Reset_Eof_Stream_f =
    0x000400, 
    Past_Eof_Stream_f = 0x000800, 
    Push_Eof_Stream_f = 0x001000, 
    Seekable_Stream_f =
    0x002000, 
    Promptable_Stream_f = 0x004000,    
    Client_Socket_Stream_f = 0x008000, 
    Server_Socket_Stream_f = 0x010000, 
    InMemory_Stream_f = 0x020000,      
    Pipe_Stream_f = 0x040000,          
    Popen_Stream_f = 0x080000,         
    User_Stream_f = 0x100000,          
    HAS_BOM_f = 0x200000,              
    RepError_Prolog_f =
    0x400000,              
    RepError_Xml_f = 0x800000, 
    DoNotCloseOnAbort_Stream_f =
    0x1000000, 
    Readline_Stream_f = 0x2000000, 
    FreeOnClose_Stream_f =
    0x4000000, 
    CloseOnException_Stream_f =
    0x8000000, 
   RepFail_Prolog_f =
   0x01000000,                  
   Aliased_Stream_f =
    0x01000000              
 } estream_f;
 
 
typedef uint64_t stream_flags_t;
 
/********* YAP C-Flags ***********************/
 
typedef enum {
  YAPC_ENABLE_GC, /* enable or disable garbage collection */
  YAPC_ENABLE_AGC /* enable or disable atom garbage collection */
} yap_flag_gc_t;
 
typedef enum yap_enum_reset_t {
  YAP_EXEC_ABSMI = 0,
  YAP_FULL_RESET = 1,
  YAP_RESET_FROM_RESTORE = 3
} yap_reset_t;
 
typedef bool (*YAP_ModInit_t)(void);
 
typedef struct {
  YAP_ModInit_t f;
  const char *s;
} YAP_delaymodule_t;
 
#endif /* _YAPDEFS_H */