C# 클래스 SbsSW.SwiPlCs.libpl

파일 보기 프로젝트 열기: swi-to-yap/swicli

공개 프로퍼티들

프로퍼티 타입 설명
NoToString bool
TermRefCount ulong

Private Properties

프로퍼티 타입 설명

공개 메소드들

메소드 설명
InternalError ( string cause, Exception exception ) : void
Is64Bit ( ) : bool
LoadLibPl ( ) : void
LoadUnmanagedPrologLibrary ( string fileName ) : SafeLibraryHandle
PL_abort_hook ( PL_abort_hook_t ah ) : void
PL_abort_unhook ( PL_abort_hook_t ah ) : int
PL_agc_hook ( PL_agc_hook_t newhook ) : PL_agc_hook_t
PL_atom_chars ( uint t_atom ) : String
PL_atom_wchars ( uint t_atom ) : String
PL_chars_to_term ( string chars, uint term ) : int
PL_cleanup ( int status ) : int
PL_close_foreign_frame ( uint fid_t ) : void
PL_close_query ( uint qid ) : void
PL_compare ( uint term1, uint term2 ) : int
PL_cons_functor_v ( uint term, uint functor_t, uint term_a0 ) : void
PL_copy_term_ref ( uint term_t ) : uint
PL_create_engine ( IntPtr attr ) : IntPtr
PL_cut_query ( uint qid ) : void
PL_destroy_engine ( IntPtr engine ) : int
PL_discard_foreign_frame ( uint fid_t ) : void
PL_erase ( uint record_t ) : void
PL_exception ( uint qid ) : uint
PL_foreign_context ( IntPtr control ) : int

long PL_foreign_context(control_t) Extracts the context from the context argument. In the call type is PL_FIRST_CALL the context value is 0L. Otherwise it is the value returned by the last PL_retry() associated with this goal (both if the call type is PL_REDO as PL_CUTTED).

PL_foreign_context_address ( IntPtr control ) : IntPtr

void * PL_foreign_context_address(control_t) Extracts an address as passed in by PL_retry_address().

PL_foreign_control ( IntPtr control ) : FRG

int PL_foreign_control(control_t) Extracts the type of call from the control argument. The return values are described above. Note: that the function should be prepared to handle the PL_CUTTED case and Note: should be aware that the other arguments are not valid in this case.

PL_get_arg ( int index, uint t, uint a ) : int
PL_get_atom ( uint term, uint &atom_t ) : int
PL_get_chars ( uint term, string &s, uint flags ) : int
PL_get_float ( uint term, double &i ) : int
PL_get_int64 ( uint term, long &i ) : int
PL_get_integer ( uint term, int &i ) : int
PL_get_intptr ( uint term, IntPtr &i ) : int
PL_get_list ( uint term_t_l, uint term_t_h, uint term_t_t ) : int
PL_get_long ( uint term, long &i ) : int
PL_get_name_arity ( uint t, uint &name, int &arity ) : int
PL_get_nil ( uint term_t ) : int
PL_get_pointer ( uint term, IntPtr &i ) : int
PL_halt ( int i ) : int
PL_initialise ( int argc, String argv ) : int
PL_is_atom ( uint term_t ) : int
PL_is_atomic ( uint term_t ) : int
PL_is_attvar ( uint termRef ) : int
PL_is_blob ( uint termRef, [ type ) : int
PL_is_compound ( uint term_t ) : int
PL_is_float ( uint term_t ) : int
PL_is_ground ( uint term_t ) : int
PL_is_initialised ( IntPtr argc, IntPtr argv ) : int
PL_is_initialised ( int &argc, String &argv ) : int

Does NOT work correct if engine is_initialised int PL_is_initialised(int *argc, char ***argv)

PL_is_integer ( uint term_t ) : int
PL_is_list ( uint term_t ) : int
PL_is_number ( uint term_t ) : int
PL_is_string ( uint term_t ) : int
PL_is_variable ( uint term_t ) : int
PL_new_atom ( string text ) : uint
PL_new_atom_wchars ( int len, string text ) : uint
PL_new_functor ( uint atom_a, int a ) : uint
PL_new_term_ref ( ) : uint
PL_new_term_refs ( int n ) : uint
PL_next_solution ( uint qid_t ) : int
PL_on_halt ( SwiOnHalt oh, void closure ) : void
PL_open_foreign_frame ( ) : uint
PL_open_query ( IntPtr module, int flags, IntPtr pred, uint term ) : uint
PL_predicate ( string name, int arity, string module ) : IntPtr
PL_put_atom ( uint term, uint atom_handle ) : void
PL_put_atom_chars ( uint term, string chars ) : void
PL_put_float ( uint term, double i ) : void
PL_put_integer ( uint term, long i ) : void
PL_put_list ( uint term_t ) : void
PL_put_list_chars ( uint term_t, string chars ) : void
PL_put_list_codes ( uint term_t, string chars ) : void
PL_put_string_chars ( uint term_t, string chars ) : void
PL_put_string_nchars ( uint term_t, int len, string chars ) : void
PL_put_term ( uint t1, uint t2 ) : void
PL_query ( uint query_type ) : uint
PL_raise_exception ( uint exception_term ) : int
PL_record ( uint term_t ) : uint
PL_recorded ( uint record_t, [ term_t ) : void
PL_register_foreign_in_module ( string module, string name, int arity, Delegate function, int flags ) : int
PL_retry ( int control ) : void

void PL_retry(long) The foreign function succeeds while leaving a choice point. On backtracking over this goal the foreign function will be called again, but the control argument now indicates it is a `Redo' call and the macro PL_foreign_context() will return the handle passed via PL_retry(). This handle is a 30 bits signed value (two bits are used for status indication).

PL_retry_address ( IntPtr control ) : void

void PL_retry_address(void *) As PL_retry(), but ensures an address as returned by malloc() is correctly recovered by PL_foreign_context_address().

PL_rewind_foreign_frame ( uint fid_t ) : void
PL_set_engine ( IntPtr engine, IntPtr &old ) : int
PL_term_type ( uint t ) : int
PL_thread_at_exit ( Delegate function, IntPtr closure, int global ) : int
PL_thread_attach_engine ( IntPtr attr ) : int
PL_thread_destroy_engine ( ) : int
PL_thread_self ( ) : int
PL_toplevel ( ) : int
PL_unify ( uint t1, uint t2 ) : int
PL_unify_atom_chars ( uint t1, string atom ) : int
PL_unify_float ( uint t1, double n ) : int
PL_unify_integer ( uint t1, Int32 n ) : int
PL_unify_integer ( uint t1, Int64 n ) : int
PL_unify_intptr ( uint term, IntPtr intptr ) : int
PL_unify_list ( uint term_t_l, uint term_t_h, uint term_t_t ) : int
PL_unify_list_chars ( uint t1, string atom ) : int
PL_unify_nil ( uint term_t ) : int
PL_unify_stream ( uint term_t, IntPtr iostream ) : int
PL_unify_string_chars ( uint t1, string atom ) : int
PL_warning ( string text ) : int
PL_write_term ( IntPtr iostream, uint term_t, int precedence, int flags ) : int
S__getiob ( ) : IntPtr
SetStreamFunction ( Streams streamType, StreamsFunction functionType, Delegate function ) : void
Slinesize ( ) : int
Snew ( ) : IntPtr

UnLoadUnmanagedLibrary ( ) : void

메소드 상세

InternalError() 공개 정적인 메소드

public static InternalError ( string cause, Exception exception ) : void
cause string
exception System.Exception
리턴 void

Is64Bit() 공개 정적인 메소드

public static Is64Bit ( ) : bool
리턴 bool

LoadLibPl() 공개 정적인 메소드

public static LoadLibPl ( ) : void
리턴 void

LoadUnmanagedPrologLibrary() 공개 정적인 메소드

public static LoadUnmanagedPrologLibrary ( string fileName ) : SafeLibraryHandle
fileName string
리턴 SafeLibraryHandle

PL_abort_hook() 공개 정적인 메소드

public static PL_abort_hook ( PL_abort_hook_t ah ) : void
ah PL_abort_hook_t
리턴 void

PL_abort_unhook() 공개 정적인 메소드

public static PL_abort_unhook ( PL_abort_hook_t ah ) : int
ah PL_abort_hook_t
리턴 int

PL_agc_hook() 공개 정적인 메소드

public static PL_agc_hook ( PL_agc_hook_t newhook ) : PL_agc_hook_t
newhook PL_agc_hook_t
리턴 PL_agc_hook_t

PL_atom_chars() 공개 정적인 메소드

public static PL_atom_chars ( uint t_atom ) : String
t_atom uint
리턴 String

PL_atom_wchars() 공개 정적인 메소드

public static PL_atom_wchars ( uint t_atom ) : String
t_atom uint
리턴 String

PL_chars_to_term() 공개 정적인 메소드

public static PL_chars_to_term ( string chars, uint term ) : int
chars string
term uint
리턴 int

PL_cleanup() 공개 정적인 메소드

public static PL_cleanup ( int status ) : int
status int
리턴 int

PL_close_foreign_frame() 공개 정적인 메소드

public static PL_close_foreign_frame ( uint fid_t ) : void
fid_t uint
리턴 void

PL_close_query() 공개 정적인 메소드

public static PL_close_query ( uint qid ) : void
qid uint
리턴 void

PL_compare() 공개 정적인 메소드

public static PL_compare ( uint term1, uint term2 ) : int
term1 uint
term2 uint
리턴 int

PL_cons_functor_v() 공개 정적인 메소드

public static PL_cons_functor_v ( uint term, uint functor_t, uint term_a0 ) : void
term uint
functor_t uint
term_a0 uint
리턴 void

PL_copy_term_ref() 공개 정적인 메소드

public static PL_copy_term_ref ( uint term_t ) : uint
term_t uint
리턴 uint

PL_create_engine() 공개 정적인 메소드

public static PL_create_engine ( IntPtr attr ) : IntPtr
attr System.IntPtr
리턴 System.IntPtr

PL_cut_query() 공개 정적인 메소드

public static PL_cut_query ( uint qid ) : void
qid uint
리턴 void

PL_destroy_engine() 공개 정적인 메소드

public static PL_destroy_engine ( IntPtr engine ) : int
engine System.IntPtr
리턴 int

PL_discard_foreign_frame() 공개 정적인 메소드

public static PL_discard_foreign_frame ( uint fid_t ) : void
fid_t uint
리턴 void

PL_erase() 공개 정적인 메소드

public static PL_erase ( uint record_t ) : void
record_t uint
리턴 void

PL_exception() 공개 정적인 메소드

public static PL_exception ( uint qid ) : uint
qid uint
리턴 uint

PL_foreign_context() 공개 정적인 메소드

long PL_foreign_context(control_t) Extracts the context from the context argument. In the call type is PL_FIRST_CALL the context value is 0L. Otherwise it is the value returned by the last PL_retry() associated with this goal (both if the call type is PL_REDO as PL_CUTTED).
public static PL_foreign_context ( IntPtr control ) : int
control System.IntPtr
리턴 int

PL_foreign_context_address() 공개 정적인 메소드

void * PL_foreign_context_address(control_t) Extracts an address as passed in by PL_retry_address().
public static PL_foreign_context_address ( IntPtr control ) : IntPtr
control System.IntPtr
리턴 System.IntPtr

PL_foreign_control() 공개 정적인 메소드

int PL_foreign_control(control_t) Extracts the type of call from the control argument. The return values are described above. Note: that the function should be prepared to handle the PL_CUTTED case and Note: should be aware that the other arguments are not valid in this case.
public static PL_foreign_control ( IntPtr control ) : FRG
control System.IntPtr
리턴 FRG

PL_get_arg() 공개 정적인 메소드

public static PL_get_arg ( int index, uint t, uint a ) : int
index int
t uint
a uint
리턴 int

PL_get_atom() 공개 정적인 메소드

public static PL_get_atom ( uint term, uint &atom_t ) : int
term uint
atom_t uint
리턴 int

PL_get_chars() 공개 정적인 메소드

public static PL_get_chars ( uint term, string &s, uint flags ) : int
term uint
s string
flags uint
리턴 int

PL_get_float() 공개 정적인 메소드

public static PL_get_float ( uint term, double &i ) : int
term uint
i double
리턴 int

PL_get_int64() 공개 정적인 메소드

public static PL_get_int64 ( uint term, long &i ) : int
term uint
i long
리턴 int

PL_get_integer() 공개 정적인 메소드

public static PL_get_integer ( uint term, int &i ) : int
term uint
i int
리턴 int

PL_get_intptr() 공개 정적인 메소드

public static PL_get_intptr ( uint term, IntPtr &i ) : int
term uint
i System.IntPtr
리턴 int

PL_get_list() 공개 정적인 메소드

public static PL_get_list ( uint term_t_l, uint term_t_h, uint term_t_t ) : int
term_t_l uint
term_t_h uint
term_t_t uint
리턴 int

PL_get_long() 공개 정적인 메소드

public static PL_get_long ( uint term, long &i ) : int
term uint
i long
리턴 int

PL_get_name_arity() 공개 정적인 메소드

public static PL_get_name_arity ( uint t, uint &name, int &arity ) : int
t uint
name uint
arity int
리턴 int

PL_get_nil() 공개 정적인 메소드

public static PL_get_nil ( uint term_t ) : int
term_t uint
리턴 int

PL_get_pointer() 공개 정적인 메소드

public static PL_get_pointer ( uint term, IntPtr &i ) : int
term uint
i System.IntPtr
리턴 int

PL_halt() 공개 정적인 메소드

public static PL_halt ( int i ) : int
i int
리턴 int

PL_initialise() 공개 정적인 메소드

public static PL_initialise ( int argc, String argv ) : int
argc int
argv String
리턴 int

PL_is_atom() 공개 정적인 메소드

public static PL_is_atom ( uint term_t ) : int
term_t uint
리턴 int

PL_is_atomic() 공개 정적인 메소드

public static PL_is_atomic ( uint term_t ) : int
term_t uint
리턴 int

PL_is_attvar() 공개 정적인 메소드

public static PL_is_attvar ( uint termRef ) : int
termRef uint
리턴 int

PL_is_blob() 공개 정적인 메소드

public static PL_is_blob ( uint termRef, [ type ) : int
termRef uint
type [
리턴 int

PL_is_compound() 공개 정적인 메소드

public static PL_is_compound ( uint term_t ) : int
term_t uint
리턴 int

PL_is_float() 공개 정적인 메소드

public static PL_is_float ( uint term_t ) : int
term_t uint
리턴 int

PL_is_ground() 공개 정적인 메소드

public static PL_is_ground ( uint term_t ) : int
term_t uint
리턴 int

PL_is_initialised() 공개 정적인 메소드

public static PL_is_initialised ( IntPtr argc, IntPtr argv ) : int
argc IntPtr
argv IntPtr
리턴 int

PL_is_initialised() 공개 정적인 메소드

Does NOT work correct if engine is_initialised int PL_is_initialised(int *argc, char ***argv)
public static PL_is_initialised ( int &argc, String &argv ) : int
argc int
argv String
리턴 int

PL_is_integer() 공개 정적인 메소드

public static PL_is_integer ( uint term_t ) : int
term_t uint
리턴 int

PL_is_list() 공개 정적인 메소드

public static PL_is_list ( uint term_t ) : int
term_t uint
리턴 int

PL_is_number() 공개 정적인 메소드

public static PL_is_number ( uint term_t ) : int
term_t uint
리턴 int

PL_is_string() 공개 정적인 메소드

public static PL_is_string ( uint term_t ) : int
term_t uint
리턴 int

PL_is_variable() 공개 정적인 메소드

public static PL_is_variable ( uint term_t ) : int
term_t uint
리턴 int

PL_new_atom() 공개 정적인 메소드

public static PL_new_atom ( string text ) : uint
text string
리턴 uint

PL_new_atom_wchars() 공개 정적인 메소드

public static PL_new_atom_wchars ( int len, string text ) : uint
len int
text string
리턴 uint

PL_new_functor() 공개 정적인 메소드

public static PL_new_functor ( uint atom_a, int a ) : uint
atom_a uint
a int
리턴 uint

PL_new_term_ref() 공개 정적인 메소드

public static PL_new_term_ref ( ) : uint
리턴 uint

PL_new_term_refs() 공개 정적인 메소드

public static PL_new_term_refs ( int n ) : uint
n int
리턴 uint

PL_next_solution() 공개 정적인 메소드

public static PL_next_solution ( uint qid_t ) : int
qid_t uint
리턴 int

PL_on_halt() 공개 정적인 메소드

public static PL_on_halt ( SwiOnHalt oh, void closure ) : void
oh SwiOnHalt
closure void
리턴 void

PL_open_foreign_frame() 공개 정적인 메소드

public static PL_open_foreign_frame ( ) : uint
리턴 uint

PL_open_query() 공개 정적인 메소드

public static PL_open_query ( IntPtr module, int flags, IntPtr pred, uint term ) : uint
module IntPtr
flags int
pred IntPtr
term uint
리턴 uint

PL_predicate() 공개 정적인 메소드

public static PL_predicate ( string name, int arity, string module ) : IntPtr
name string
arity int
module string
리턴 IntPtr

PL_put_atom() 공개 정적인 메소드

public static PL_put_atom ( uint term, uint atom_handle ) : void
term uint
atom_handle uint
리턴 void

PL_put_atom_chars() 공개 정적인 메소드

public static PL_put_atom_chars ( uint term, string chars ) : void
term uint
chars string
리턴 void

PL_put_float() 공개 정적인 메소드

public static PL_put_float ( uint term, double i ) : void
term uint
i double
리턴 void

PL_put_integer() 공개 정적인 메소드

public static PL_put_integer ( uint term, long i ) : void
term uint
i long
리턴 void

PL_put_list() 공개 정적인 메소드

public static PL_put_list ( uint term_t ) : void
term_t uint
리턴 void

PL_put_list_chars() 공개 정적인 메소드

public static PL_put_list_chars ( uint term_t, string chars ) : void
term_t uint
chars string
리턴 void

PL_put_list_codes() 공개 정적인 메소드

public static PL_put_list_codes ( uint term_t, string chars ) : void
term_t uint
chars string
리턴 void

PL_put_string_chars() 공개 정적인 메소드

public static PL_put_string_chars ( uint term_t, string chars ) : void
term_t uint
chars string
리턴 void

PL_put_string_nchars() 공개 정적인 메소드

public static PL_put_string_nchars ( uint term_t, int len, string chars ) : void
term_t uint
len int
chars string
리턴 void

PL_put_term() 공개 정적인 메소드

public static PL_put_term ( uint t1, uint t2 ) : void
t1 uint
t2 uint
리턴 void

PL_query() 공개 정적인 메소드

public static PL_query ( uint query_type ) : uint
query_type uint
리턴 uint

PL_raise_exception() 공개 정적인 메소드

public static PL_raise_exception ( uint exception_term ) : int
exception_term uint
리턴 int

PL_record() 공개 정적인 메소드

public static PL_record ( uint term_t ) : uint
term_t uint
리턴 uint

PL_recorded() 공개 정적인 메소드

public static PL_recorded ( uint record_t, [ term_t ) : void
record_t uint
term_t [
리턴 void

PL_register_foreign_in_module() 공개 정적인 메소드

public static PL_register_foreign_in_module ( string module, string name, int arity, Delegate function, int flags ) : int
module string
name string
arity int
function Delegate
flags int
리턴 int

PL_retry() 공개 정적인 메소드

void PL_retry(long) The foreign function succeeds while leaving a choice point. On backtracking over this goal the foreign function will be called again, but the control argument now indicates it is a `Redo' call and the macro PL_foreign_context() will return the handle passed via PL_retry(). This handle is a 30 bits signed value (two bits are used for status indication).
public static PL_retry ( int control ) : void
control int
리턴 void

PL_retry_address() 공개 정적인 메소드

void PL_retry_address(void *) As PL_retry(), but ensures an address as returned by malloc() is correctly recovered by PL_foreign_context_address().
public static PL_retry_address ( IntPtr control ) : void
control IntPtr
리턴 void

PL_rewind_foreign_frame() 공개 정적인 메소드

public static PL_rewind_foreign_frame ( uint fid_t ) : void
fid_t uint
리턴 void

PL_set_engine() 공개 정적인 메소드

public static PL_set_engine ( IntPtr engine, IntPtr &old ) : int
engine IntPtr
old IntPtr
리턴 int

PL_term_type() 공개 정적인 메소드

public static PL_term_type ( uint t ) : int
t uint
리턴 int

PL_thread_at_exit() 공개 정적인 메소드

public static PL_thread_at_exit ( Delegate function, IntPtr closure, int global ) : int
function Delegate
closure IntPtr
global int
리턴 int

PL_thread_attach_engine() 공개 정적인 메소드

public static PL_thread_attach_engine ( IntPtr attr ) : int
attr IntPtr
리턴 int

PL_thread_destroy_engine() 공개 정적인 메소드

public static PL_thread_destroy_engine ( ) : int
리턴 int

PL_thread_self() 공개 정적인 메소드

public static PL_thread_self ( ) : int
리턴 int

PL_toplevel() 공개 정적인 메소드

public static PL_toplevel ( ) : int
리턴 int

PL_unify() 공개 정적인 메소드

public static PL_unify ( uint t1, uint t2 ) : int
t1 uint
t2 uint
리턴 int

PL_unify_atom_chars() 공개 정적인 메소드

public static PL_unify_atom_chars ( uint t1, string atom ) : int
t1 uint
atom string
리턴 int

PL_unify_float() 공개 정적인 메소드

public static PL_unify_float ( uint t1, double n ) : int
t1 uint
n double
리턴 int

PL_unify_integer() 공개 정적인 메소드

public static PL_unify_integer ( uint t1, Int32 n ) : int
t1 uint
n Int32
리턴 int

PL_unify_integer() 공개 정적인 메소드

public static PL_unify_integer ( uint t1, Int64 n ) : int
t1 uint
n Int64
리턴 int

PL_unify_intptr() 공개 정적인 메소드

public static PL_unify_intptr ( uint term, IntPtr intptr ) : int
term uint
intptr IntPtr
리턴 int

PL_unify_list() 공개 정적인 메소드

public static PL_unify_list ( uint term_t_l, uint term_t_h, uint term_t_t ) : int
term_t_l uint
term_t_h uint
term_t_t uint
리턴 int

PL_unify_list_chars() 공개 정적인 메소드

public static PL_unify_list_chars ( uint t1, string atom ) : int
t1 uint
atom string
리턴 int

PL_unify_nil() 공개 정적인 메소드

public static PL_unify_nil ( uint term_t ) : int
term_t uint
리턴 int

PL_unify_stream() 공개 정적인 메소드

public static PL_unify_stream ( uint term_t, IntPtr iostream ) : int
term_t uint
iostream IntPtr
리턴 int

PL_unify_string_chars() 공개 정적인 메소드

public static PL_unify_string_chars ( uint t1, string atom ) : int
t1 uint
atom string
리턴 int

PL_warning() 공개 정적인 메소드

public static PL_warning ( string text ) : int
text string
리턴 int

PL_write_term() 공개 정적인 메소드

public static PL_write_term ( IntPtr iostream, uint term_t, int precedence, int flags ) : int
iostream IntPtr
term_t uint
precedence int
flags int
리턴 int

S__getiob() 공개 정적인 메소드

public static S__getiob ( ) : IntPtr
리턴 IntPtr

SetStreamFunction() 공개 정적인 메소드

public static SetStreamFunction ( Streams streamType, StreamsFunction functionType, Delegate function ) : void
streamType Streams
functionType StreamsFunction
function Delegate
리턴 void

Slinesize() 공개 정적인 메소드

public static Slinesize ( ) : int
리턴 int

Snew() 공개 정적인 메소드

public static Snew ( ) : IntPtr
리턴 IntPtr

UnLoadUnmanagedLibrary() 공개 정적인 메소드

public static UnLoadUnmanagedLibrary ( ) : void
리턴 void

프로퍼티 상세

NoToString 공개적으로 정적으로 프로퍼티

public static bool NoToString
리턴 bool

TermRefCount 공개적으로 정적으로 프로퍼티

public static ulong TermRefCount
리턴 ulong