summaryrefslogtreecommitdiffstats
path: root/contrib
diff options
context:
space:
mode:
Diffstat (limited to 'contrib')
-rw-r--r--contrib/csharp/embedding/embedding.userprefs12
-rw-r--r--contrib/csharp/embedding/embedding/embedding.csproj8
-rw-r--r--contrib/src/swi-pl/SWI-cpp.h1093
3 files changed, 1112 insertions, 1 deletions
diff --git a/contrib/csharp/embedding/embedding.userprefs b/contrib/csharp/embedding/embedding.userprefs
new file mode 100644
index 0000000..05e379d
--- /dev/null
+++ b/contrib/csharp/embedding/embedding.userprefs
@@ -0,0 +1,12 @@
+<Properties>
+ <MonoDevelop.Ide.Workspace ActiveConfiguration="Debug|x86" />
+ <MonoDevelop.Ide.Workbench ActiveDocument="embedding/Program.cs">
+ <Files>
+ <File FileName="embedding/Program.cs" Line="31" Column="1" />
+ </Files>
+ </MonoDevelop.Ide.Workbench>
+ <MonoDevelop.Ide.DebuggingService.Breakpoints>
+ <BreakpointStore />
+ </MonoDevelop.Ide.DebuggingService.Breakpoints>
+ <MonoDevelop.Ide.DebuggingService.PinnedWatches />
+</Properties> \ No newline at end of file
diff --git a/contrib/csharp/embedding/embedding/embedding.csproj b/contrib/csharp/embedding/embedding/embedding.csproj
index 9c22f6c..53e1eed 100644
--- a/contrib/csharp/embedding/embedding/embedding.csproj
+++ b/contrib/csharp/embedding/embedding/embedding.csproj
@@ -23,6 +23,12 @@
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
+ <EnvironmentVariables>
+ <EnvironmentVariables>
+ <Variable name="DYLD_FALLBACK_LIBRARY_PATH" value="/Users/sradomski/Documents/TK/Code/uscxml/build/cli/lib/csharp" />
+ <Variable name="MONO_LOG_LEVEL" value="debug" />
+ </EnvironmentVariables>
+ </EnvironmentVariables>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
<PlatformTarget>x86</PlatformTarget>
@@ -42,7 +48,7 @@
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
<Reference Include="uscxmlCSharp">
- <HintPath>C:\Users\sradomski\Desktop\build\lib\uscxmlCSharp.dll</HintPath>
+ <HintPath>..\..\..\..\build\cli\lib\uscxmlCSharp.dll</HintPath>
</Reference>
</ItemGroup>
<ItemGroup>
diff --git a/contrib/src/swi-pl/SWI-cpp.h b/contrib/src/swi-pl/SWI-cpp.h
new file mode 100644
index 0000000..d32a052
--- /dev/null
+++ b/contrib/src/swi-pl/SWI-cpp.h
@@ -0,0 +1,1093 @@
+/* $Id$
+
+ Part of SWI-Prolog
+
+ Author: Jan Wielemaker
+ E-mail: J.Wielemaker@cs.vu.nl
+ WWW: http://www.swi-prolog.org
+ Copyright (C): 1985-2009, University of Amsterdam
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef _SWI_CPP_H
+#define _SWI_CPP_H
+
+#include <SWI-Prolog.h>
+#include <string.h>
+#ifndef __APPLE__
+#include <malloc.h>
+#endif
+
+#ifdef __BORLANDC__
+#define __inline inline
+#endif
+
+#ifdef _MSC_VER /* MSVC doesn't know throw doesn't return */
+#define PL_THROWN(value) return value;
+#else
+#define PL_THROWN(v) (void)0
+#endif
+
+class PlTerm;
+class PlTermv;
+
+ /*******************************
+ * PROLOG CONSTANTS *
+ *******************************/
+
+class PlFunctor
+{
+public:
+ functor_t functor;
+
+ PlFunctor(const char *name, int arity)
+ { functor = PL_new_functor(PL_new_atom(name), arity);
+ }
+};
+
+
+class PlAtom
+{
+public:
+ atom_t handle;
+
+ PlAtom(atom_t h)
+ { handle = h;
+ }
+ PlAtom(const char *text)
+ { handle = PL_new_atom(text);
+ }
+ PlAtom(const PlTerm &t);
+
+ operator const char *(void)
+ { return PL_atom_chars(handle);
+ }
+
+ int operator ==(const char *s)
+ { return strcmp(s, PL_atom_chars(handle)) == 0;
+ }
+ int operator ==(const PlAtom &a)
+ { return handle == a.handle;
+ }
+};
+
+ /*******************************
+ * GENERIC PROLOG TERM *
+ *******************************/
+
+
+class PlTerm
+{
+public:
+ term_t ref;
+
+ PlTerm();
+ PlTerm(term_t t)
+ { ref = t;
+ }
+
+ /* C --> PlTerm */
+ PlTerm(const char *text);
+ PlTerm(long val);
+ PlTerm(double val);
+ PlTerm(const PlAtom &a);
+ PlTerm(void *ptr);
+
+ /* PlTerm --> C */
+ operator term_t(void) const
+ { return ref;
+ }
+ operator char *(void) const;
+ operator long(void) const;
+ operator int(void) const;
+ operator double(void) const;
+ operator PlAtom(void) const;
+ operator void *(void) const;
+
+ int type()
+ { return PL_term_type(ref);
+ }
+
+ /* Compounds */
+ PlTerm operator [](int index) const;
+ int arity();
+ const char *name();
+
+ /* UNIFY */
+ int operator =(const PlTerm &t2); /* term */
+ int operator =(const PlAtom &a); /* atom */
+ int operator =(const char *v); /* atom (from char *) */
+ int operator =(long v); /* integer */
+ int operator =(int v); /* integer */
+ int operator =(double v); /* float */
+ int operator =(const PlFunctor &f); /* functor */
+
+ /* Comparison standard order terms */
+ int operator ==(const PlTerm &t2)
+ { return PL_compare(ref, t2.ref) == 0;
+ }
+ int operator !=(const PlTerm &t2)
+ { return PL_compare(ref, t2.ref) != 0;
+ }
+ int operator <(const PlTerm &t2)
+ { return PL_compare(ref, t2.ref) < 0;
+ }
+ int operator >(const PlTerm &t2)
+ { return PL_compare(ref, t2.ref) > 0;
+ }
+ int operator <=(const PlTerm &t2)
+ { return PL_compare(ref, t2.ref) <= 0;
+ }
+ int operator >=(const PlTerm &t2)
+ { return PL_compare(ref, t2.ref) >= 0;
+ }
+ /* comparison (long) */
+ int operator ==(long v);
+ int operator !=(long v);
+ int operator <(long v);
+ int operator >(long v);
+ int operator <=(long v);
+ int operator >=(long v);
+
+ /* comparison (string) */
+ int operator ==(const char *s);
+ int operator ==(const PlAtom &a);
+};
+
+
+ /*******************************
+ * TERM VECTOR *
+ *******************************/
+
+class PlTermv
+{
+public:
+ term_t a0;
+ int size;
+
+ PlTermv(int n)
+ { a0 = PL_new_term_refs(n);
+ size = n;
+ }
+ PlTermv(int n, term_t t0)
+ { a0 = t0;
+ size = n;
+ }
+
+ /* create from args */
+ PlTermv(PlTerm m0);
+ PlTermv(PlTerm m0, PlTerm m1);
+ PlTermv(PlTerm m0, PlTerm m1, PlTerm m2);
+ PlTermv(PlTerm m0, PlTerm m1, PlTerm m2, PlTerm m3);
+ PlTermv(PlTerm m0, PlTerm m1, PlTerm m2, PlTerm m3, PlTerm m4);
+
+ PlTerm operator [](int n) const;
+};
+
+ /*******************************
+ * SPECIALISED TERMS *
+ *******************************/
+
+class PlCompound : public PlTerm
+{
+public:
+
+ PlCompound(const char *text);
+ PlCompound(const char *functor, const PlTermv &args);
+};
+
+
+class PlString : public PlTerm
+{
+public:
+
+ PlString(const char *text);
+ PlString(const char *text, int len);
+};
+
+
+class PlCodeList : public PlTerm
+{
+public:
+
+ PlCodeList(const char *text);
+};
+
+
+class PlCharList : public PlTerm
+{
+public:
+
+ PlCharList(const char *text);
+};
+
+
+ /*******************************
+ * EXCEPTIONS *
+ *******************************/
+
+class PlException : public PlTerm
+{
+public:
+ PlException()
+ { term_t ex = PL_exception(0);
+ if ( ex )
+ ref = ex;
+ else
+ PL_fatal_error("No exception");
+ }
+
+ PlException(const PlTerm &t)
+ { ref = t.ref;
+ }
+
+ operator const char *(void);
+
+ int plThrow()
+ { return PL_raise_exception(ref);
+ }
+
+ void cppThrow();
+};
+
+
+class PlTypeError : public PlException
+{
+public:
+
+ PlTypeError(const PlTerm &t) : PlException(t) {}
+
+ PlTypeError(const char *expected, PlTerm actual) :
+ PlException(PlCompound("error",
+ PlTermv(PlCompound("type_error",
+ PlTermv(expected, actual)),
+ PlTerm())))
+ {
+ }
+};
+
+
+class PlDomainError : public PlException
+{
+public:
+
+ PlDomainError(const PlTerm &t) : PlException(t) {}
+
+ PlDomainError(const char *expected, PlTerm actual) :
+ PlException(PlCompound("error",
+ PlTermv(PlCompound("domain_error",
+ PlTermv(expected, actual)),
+ PlTerm())))
+ {
+ }
+};
+
+
+class PlResourceError : public PlException
+{
+public:
+ PlResourceError() : PlException() {}
+
+ PlResourceError(const PlTerm &t) : PlException(t) {}
+
+ PlResourceError(const char *resource) :
+ PlException(PlCompound("error",
+ PlTermv(PlCompound("resource_error",
+ PlTermv(PlTerm(resource))),
+ PlTerm())))
+ {
+ }
+};
+
+
+class PlTermvDomainError : public PlException
+{
+public:
+
+ PlTermvDomainError(int size, int n) :
+ PlException(PlCompound("error",
+ PlTermv(PlCompound("domain_error",
+ PlTermv(PlCompound("argv",
+ size),
+ PlTerm((long)n))),
+ PlTerm())))
+ {
+ }
+};
+
+
+ /*******************************
+ * PLTERM IMPLEMENTATION *
+ *******************************/
+
+__inline
+PlTerm::PlTerm()
+{ if ( !(ref = PL_new_term_ref()) )
+ throw PlResourceError();
+}
+
+__inline
+PlTerm::PlTerm(const char *text)
+{ if ( !(ref = PL_new_term_ref()) ||
+ !PL_put_atom_chars(ref, text) )
+ throw PlResourceError();
+}
+
+__inline
+PlTerm::PlTerm(long val)
+{ if ( !(ref = PL_new_term_ref()) ||
+ !PL_put_integer(ref, val) )
+ throw PlResourceError();
+}
+
+__inline
+PlTerm::PlTerm(double val)
+{ ref = PL_new_term_ref();
+
+ if ( !PL_put_float(ref, val) )
+ throw PlResourceError();
+}
+
+__inline
+PlTerm::PlTerm(const PlAtom &a)
+{ if ( !(ref = PL_new_term_ref()) )
+ throw PlResourceError();
+
+ PL_put_atom(ref, a.handle);
+}
+
+__inline
+PlTerm::PlTerm(void *ptr)
+{ if ( !(ref = PL_new_term_ref()) ||
+ !PL_put_pointer(ref, ptr) )
+ throw PlResourceError();
+}
+
+ /*******************************
+ * SPECIALISED IMPLEMENTATIONS *
+ *******************************/
+
+__inline
+PlString::PlString(const char *text) : PlTerm()
+{ if ( !PL_put_string_chars(ref, text) )
+ throw PlResourceError();
+}
+
+__inline
+PlString::PlString(const char *text, int len) : PlTerm()
+{ if ( !PL_put_string_nchars(ref, len, text) )
+ throw PlResourceError();
+}
+
+__inline
+PlCodeList::PlCodeList(const char *text) : PlTerm()
+{ if ( !PL_put_list_codes(ref, text) )
+ throw PlResourceError();
+}
+
+__inline
+PlCharList::PlCharList(const char *text) : PlTerm()
+{ if ( !PL_put_list_chars(ref, text) )
+ throw PlResourceError();
+}
+
+
+ /*******************************
+ * LISTS *
+ *******************************/
+
+class PlTail : public PlTerm
+{
+public:
+
+ PlTail(const PlTerm &l)
+ { if ( PL_is_variable(l.ref) || PL_is_list(l.ref) )
+ { if ( !(ref = PL_copy_term_ref(l.ref)) )
+ throw PlResourceError();
+ } else
+ throw PlTypeError("list", l.ref);
+ }
+
+ /* building */
+ int append(const PlTerm &e)
+ { term_t tmp, ex;
+
+ if ( (tmp = PL_new_term_ref()) &&
+ PL_unify_list(ref, tmp, ref) &&
+ PL_unify(tmp, e.ref) )
+ { PL_reset_term_refs(tmp);
+ return TRUE;
+ }
+
+ if ( (ex = PL_exception(0)) )
+ throw PlResourceError(ex);
+
+ return FALSE;
+ }
+ int close()
+ { return PL_unify_nil(ref);
+ }
+
+ /* enumerating */
+ int next(PlTerm &t)
+ { if ( PL_get_list(ref, t, ref) )
+ return TRUE;
+
+ if ( PL_get_nil(ref) )
+ return FALSE;
+
+ throw PlTypeError("list", ref);
+ PL_THROWN(FALSE);
+ }
+};
+
+
+ /*******************************
+ * REGISTER *
+ *******************************/
+
+
+class PlRegister
+{
+public:
+
+ PlRegister(const char *module, const char *name, int arity,
+ foreign_t (f)(term_t t0, int a, control_t ctx))
+ { PL_register_foreign_in_module(module, name, arity, (void *)f, PL_FA_VARARGS);
+ }
+
+ PlRegister(const char *module, const char *name, foreign_t (*f)(PlTerm a0))
+ { PL_register_foreign_in_module(module, name, 1, (void *)f, 0);
+ }
+ PlRegister(const char *module, const char *name, foreign_t (*f)(PlTerm a0, PlTerm a1))
+ { PL_register_foreign_in_module(module, name, 2, (void *)f, 0);
+ }
+ PlRegister(const char *module, const char *name, foreign_t (*f)(PlTerm a0, PlTerm a1, PlTerm a2))
+ { PL_register_foreign_in_module(module, name, 3, (void *)f, 0);
+ }
+
+ // for non-deterministic calls
+ PlRegister(const char *module, const char *name, int arity,
+ foreign_t (f)(term_t t0, int a, control_t ctx), short flags)
+ { PL_register_foreign_in_module(module, name, arity, (void *)f, flags);
+ }
+
+};
+
+
+ /*******************************
+ * CALLING PROLOG *
+ *******************************/
+
+class PlFrame
+{
+public:
+ fid_t fid;
+
+ PlFrame()
+ { fid = PL_open_foreign_frame();
+ }
+
+ ~PlFrame()
+ { PL_close_foreign_frame(fid);
+ }
+
+ void rewind()
+ { PL_rewind_foreign_frame(fid);
+ }
+};
+
+
+class PlQuery
+{
+public:
+ qid_t qid;
+
+ PlQuery(const char *name, const PlTermv &av)
+ { predicate_t p = PL_predicate(name, av.size, "user");
+
+ qid = PL_open_query((module_t)0, PL_Q_CATCH_EXCEPTION, p, av.a0);
+ if ( !qid )
+ throw PlResourceError();
+ }
+ PlQuery(const char *module, const char *name, const PlTermv &av)
+ { atom_t ma = PL_new_atom(module);
+ atom_t na = PL_new_atom(name);
+ module_t m = PL_new_module(ma);
+ predicate_t p = PL_pred(PL_new_functor(na, av.size), m);
+
+ PL_unregister_atom(ma);
+ PL_unregister_atom(na);
+
+ qid = PL_open_query(m, PL_Q_CATCH_EXCEPTION, p, av.a0);
+ if ( !qid )
+ throw PlResourceError();
+ }
+
+ ~PlQuery()
+ { PL_cut_query(qid);
+ }
+
+ int next_solution();
+};
+
+
+__inline int
+PlCall(const char *predicate, const PlTermv &args)
+{ PlQuery q(predicate, args);
+ return q.next_solution();
+}
+
+__inline int
+PlCall(const char *module, const char *predicate, const PlTermv &args)
+{ PlQuery q(module, predicate, args);
+ return q.next_solution();
+}
+
+__inline int
+PlCall(const char *goal)
+{ PlQuery q("call", PlTermv(PlCompound(goal)));
+ return q.next_solution();
+}
+
+
+
+ /*******************************
+ * ATOM (BODY) *
+ *******************************/
+
+__inline
+PlAtom::PlAtom(const PlTerm &t)
+{ atom_t a;
+
+ if ( PL_get_atom(t.ref, &a) )
+ handle = a;
+ else
+ throw PlTypeError("atom", t);
+}
+
+
+ /*******************************
+ * TERM (BODY) *
+ *******************************/
+
+ /* PlTerm --> C */
+
+__inline PlTerm::operator char *(void) const
+{ char *s;
+
+ if ( PL_get_chars(ref, &s, CVT_ALL|CVT_WRITE|BUF_RING) )
+ return s;
+
+ throw PlTypeError("text", ref);
+ PL_THROWN(NULL);
+}
+
+__inline PlTerm::operator long(void) const
+{ long v;
+
+ if ( PL_get_long(ref, &v) )
+ return v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0L);
+}
+
+__inline PlTerm::operator int(void) const
+{ int v;
+
+ if ( PL_get_integer(ref, &v) )
+ return v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0);
+}
+
+__inline PlTerm::operator double(void) const
+{ double v;
+
+ if ( PL_get_float(ref, &v) )
+ return v;
+
+ throw PlTypeError("float", ref);
+ PL_THROWN(0.0);
+}
+
+__inline PlTerm::operator PlAtom(void) const
+{ atom_t v;
+
+ if ( PL_get_atom(ref, &v) )
+ return PlAtom(v);
+
+ throw PlTypeError("atom", ref);
+ PL_THROWN((atom_t)0);
+}
+
+__inline PlTerm::operator void *(void) const
+{ void *ptr;
+
+ if ( PL_get_pointer(ref, &ptr) )
+ return ptr;
+
+ throw PlTypeError("pointer", ref);
+ PL_THROWN(NULL);
+}
+
+ /* compounds */
+
+__inline PlTerm
+PlTerm::operator [](int index) const
+{ PlTerm t;
+
+ if ( PL_get_arg(index, ref, t.ref) )
+ return t;
+
+ if ( !PL_is_compound(ref) )
+ throw PlTypeError("compound", ref);
+ else
+ { if ( !PL_put_integer(t.ref, index) )
+ throw PlResourceError();
+
+ if ( index < 1 )
+ throw PlDomainError("not_less_than_zero", t.ref);
+ else
+ throw PlDomainError("arity", t.ref); /* TBD: proper exception */
+ }
+ PL_THROWN((term_t)0);
+}
+
+
+__inline int
+PlTerm::arity()
+{ atom_t name;
+ int arity;
+
+ if ( PL_get_name_arity(ref, &name, &arity) )
+ return arity;
+
+ throw PlTypeError("compound", ref);
+ PL_THROWN(0);
+}
+
+
+__inline const char *
+PlTerm::name()
+{ atom_t name;
+ int arity;
+
+ if ( PL_get_name_arity(ref, &name, &arity) )
+ return PL_atom_chars(name);
+
+ throw PlTypeError("compound", ref);
+ PL_THROWN(NULL);
+}
+
+
+ /* Unification */
+
+__inline int PlTerm::operator =(const PlTerm &t2) /* term = term */
+{ int rc = PL_unify(ref, t2.ref);
+ term_t ex;
+
+ if ( !rc && (ex=PL_exception(0)) )
+ throw PlResourceError(ex);
+ return rc;
+}
+
+__inline int PlTerm::operator =(const PlAtom &a) /* term = atom */
+{ int rc = PL_unify_atom(ref, a.handle);
+ term_t ex;
+
+ if ( !rc && (ex=PL_exception(0)) )
+ throw PlResourceError(ex);
+ return rc;
+}
+
+__inline int PlTerm::operator =(const char *v) /* term = atom */
+{ int rc = PL_unify_atom_chars(ref, v);
+ term_t ex;
+
+ if ( !rc && (ex=PL_exception(0)) )
+ throw PlResourceError(ex);
+ return rc;
+}
+
+__inline int PlTerm::operator =(long v)
+{ int rc = PL_unify_integer(ref, v);
+ term_t ex;
+
+ if ( !rc && (ex=PL_exception(0)) )
+ throw PlResourceError(ex);
+ return rc;
+}
+
+__inline int PlTerm::operator =(int v)
+{ int rc = PL_unify_integer(ref, v);
+ term_t ex;
+
+ if ( !rc && (ex=PL_exception(0)) )
+ throw PlResourceError(ex);
+ return rc;
+}
+
+__inline int PlTerm::operator =(double v)
+{ int rc = PL_unify_float(ref, v);
+ term_t ex;
+
+ if ( !rc && (ex=PL_exception(0)) )
+ throw PlResourceError(ex);
+ return rc;
+}
+
+__inline int PlTerm::operator =(const PlFunctor &f)
+{ int rc = PL_unify_functor(ref, f.functor);
+ term_t ex;
+
+ if ( !rc && (ex=PL_exception(0)) )
+ throw PlResourceError(ex);
+ return rc;
+}
+
+ /* comparison */
+
+
+__inline int PlTerm::operator ==(long v)
+{ long v0;
+
+ if ( PL_get_long(ref, &v0) )
+ return v0 == v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0);
+}
+
+__inline int PlTerm::operator !=(long v)
+{ long v0;
+
+ if ( PL_get_long(ref, &v0) )
+ return v0 != v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0);
+}
+
+__inline int PlTerm::operator <(long v)
+{ long v0;
+
+ if ( PL_get_long(ref, &v0) )
+ return v0 < v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0);
+}
+
+__inline int PlTerm::operator >(long v)
+{ long v0;
+
+ if ( PL_get_long(ref, &v0) )
+ return v0 > v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0);
+}
+
+__inline int PlTerm::operator <=(long v)
+{ long v0;
+
+ if ( PL_get_long(ref, &v0) )
+ return v0 <= v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0);
+}
+
+__inline int PlTerm::operator >=(long v)
+{ long v0;
+
+ if ( PL_get_long(ref, &v0) )
+ return v0 >= v;
+
+ throw PlTypeError("integer", ref);
+ PL_THROWN(0);
+}
+
+ /* comparison (string) */
+
+__inline int PlTerm::operator ==(const char *s)
+{ char *s0;
+
+ if ( PL_get_chars(ref, &s0, CVT_ALL) )
+ return strcmp(s0, s) == 0;
+
+ throw PlTypeError("text", ref);
+ PL_THROWN(0);
+}
+
+
+__inline int PlTerm::operator ==(const PlAtom &a)
+{ atom_t v;
+
+ if ( PL_get_atom(ref, &v) )
+ return v == a.handle;
+
+ throw PlTypeError("atom", ref);
+ PL_THROWN(0);
+}
+
+
+ /*******************************
+ * COMPPOUND (BODY) *
+ *******************************/
+
+
+__inline
+PlCompound::PlCompound(const char *text) : PlTerm()
+{ term_t t = PL_new_term_ref();
+
+ if ( !PL_chars_to_term(text, t) )
+ throw PlException(t);
+
+ PL_put_term(ref, t);
+}
+
+__inline
+PlCompound::PlCompound(const char *functor, const PlTermv &args) : PlTerm()
+{ if ( !PL_cons_functor_v(ref,
+ PL_new_functor(PL_new_atom(functor), args.size),
+ args.a0) )
+ throw PlResourceError();
+}
+
+ /*******************************
+ * TERMV (BODY) *
+ *******************************/
+
+
+__inline PlTermv::PlTermv(PlTerm m0)
+{ size = 1;
+ a0 = m0.ref;
+}
+
+__inline PlTermv::PlTermv(PlTerm m0, PlTerm m1)
+{ size = 2;
+ if ( !(a0 = PL_new_term_refs(2)) )
+ throw PlResourceError();
+ PL_put_term(a0+0, m0);
+ PL_put_term(a0+1, m1);
+}
+
+__inline PlTermv::PlTermv(PlTerm m0, PlTerm m1, PlTerm m2)
+{ size = 3;
+ if ( !(a0 = PL_new_term_refs(3)) )
+ throw PlResourceError();
+ PL_put_term(a0+0, m0);
+ PL_put_term(a0+1, m1);
+ PL_put_term(a0+2, m2);
+}
+
+__inline PlTermv::PlTermv(PlTerm m0, PlTerm m1, PlTerm m2, PlTerm m3)
+{ size = 4;
+ if ( !(a0 = PL_new_term_refs(4)) )
+ throw PlResourceError();
+ PL_put_term(a0+0, m0);
+ PL_put_term(a0+1, m1);
+ PL_put_term(a0+2, m2);
+
+ PL_put_term(a0+3, m3);
+}
+
+__inline PlTermv::PlTermv(PlTerm m0, PlTerm m1, PlTerm m2,
+ PlTerm m3, PlTerm m4)
+{ size = 5;
+ if ( !(a0 = PL_new_term_refs(5)) )
+ throw PlResourceError();
+ PL_put_term(a0+0, m0);
+ PL_put_term(a0+1, m1);
+ PL_put_term(a0+2, m2);
+ PL_put_term(a0+3, m3);
+ PL_put_term(a0+4, m4);
+}
+
+
+__inline PlTerm
+PlTermv::operator [](int n) const
+{ if ( n < 0 || n >= size )
+ throw PlTermvDomainError(size, n);
+
+ return PlTerm(a0+n);
+}
+
+
+ /*******************************
+ * EXCEPTIONS (BODY) *
+ *******************************/
+
+__inline PlException::operator const char *(void)
+{ PlFrame fr;
+#ifdef USE_PRINT_MESSAGE
+ PlTermv av(2);
+
+ av[0] = PlCompound("print_message",
+ PlTermv("error", ref));
+ PlQuery q("$write_on_string", av);
+ if ( q.next_solution() )
+ return (char *)av[1];
+#else
+ PlTermv av(2);
+ av[0] = PlTerm(ref);
+ PlQuery q("$messages", "message_to_string", av);
+ if ( q.next_solution() )
+ return (char *)av[1];
+#endif
+ return "[ERROR: Failed to generate message. Internal error]\n";
+}
+
+
+__inline void
+PlException::cppThrow()
+{ term_t a = PL_new_term_ref();
+ atom_t name;
+ int arity;
+
+ if ( PL_get_arg(1, ref, a) &&
+ PL_get_name_arity(a, &name, &arity) )
+ { const char *s = PL_atom_chars(name);
+
+ if ( strcmp(s, "type_error") == 0 )
+ throw PlTypeError(ref);
+ if ( strcmp(s, "domain_error") == 0 )
+ throw PlDomainError(ref);
+ if ( strcmp(s, "resource_error") == 0 )
+ throw PlResourceError(ref);
+ }
+
+ throw *this;
+}
+
+
+ /*******************************
+ * QUERY (BODY) *
+ *******************************/
+
+__inline int
+PlQuery::next_solution()
+{ int rval;
+
+ if ( !(rval = PL_next_solution(qid)) )
+ { term_t ex;
+
+ if ( (ex = PL_exception(qid)) )
+ PlException(ex).cppThrow();
+ }
+ return rval;
+}
+
+
+ /*******************************
+ * ENGINE *
+ *******************************/
+
+class PlError
+{
+public:
+ char *message;
+
+ PlError(const char *msg)
+ { message = new char[strlen(msg+1)];
+ strcpy(message, msg);
+ }
+};
+
+
+class PlEngine
+{
+public:
+
+ PlEngine(int argc, char **argv)
+ { if ( !PL_initialise(argc, argv) )
+ throw PlError("failed to initialise");
+ }
+
+ PlEngine(char *av0)
+ { int ac = 0;
+ char **av = (char **)malloc(sizeof(char *) * 2);
+
+ av[ac++] = av0;
+
+ if ( !PL_initialise(1, av) )
+ throw PlError("failed to initialise");
+ }
+
+ ~PlEngine()
+ { PL_cleanup(0);
+ }
+};
+
+
+ /*******************************
+ * REGISTER PREDICATES *
+ *******************************/
+
+#ifndef PROLOG_MODULE
+#define PROLOG_MODULE (const char*)NULL
+#endif
+
+#define PREDICATE(name, arity) \
+ static foreign_t \
+ pl_ ## name ## __ ## arity(PlTermv _av); \
+ static foreign_t \
+ _pl_ ## name ## __ ## arity(term_t t0, int a, control_t c) \
+ { try \
+ { \
+ return pl_ ## name ## __ ## arity(PlTermv(arity, t0)); \
+ } catch ( PlException &ex ) \
+ { return ex.plThrow(); \
+ } \
+ } \
+ static PlRegister _x ## name ## __ ## arity(PROLOG_MODULE, #name, arity, \
+ _pl_ ## name ## __ ## arity); \
+ static foreign_t pl_ ## name ## __ ## arity(PlTermv _av)
+
+
+#define PREDICATE_NONDET(name, arity) \
+ static foreign_t \
+ pl_ ## name ## __ ## arity(PlTermv _av, foreign_t handle); \
+ static foreign_t \
+ _pl_ ## name ## __ ## arity(term_t t0, int a, control_t c) \
+ { try \
+ { \
+ return pl_ ## name ## __ ## arity(PlTermv(arity, t0), (foreign_t)c); \
+ } catch ( PlException &ex ) \
+ { return ex.plThrow(); \
+ } \
+ } \
+ static PlRegister _x ## name ## __ ## arity(PROLOG_MODULE, #name, arity, \
+ _pl_ ## name ## __ ## arity, \
+ PL_FA_NONDETERMINISTIC | PL_FA_VARARGS); \
+ static foreign_t pl_ ## name ## __ ## arity(PlTermv _av, foreign_t handle)
+
+#define A1 _av[0]
+#define A2 _av[1]
+#define A3 _av[2]
+#define A4 _av[3]
+#define A5 _av[4]
+#define A6 _av[5]
+#define A7 _av[6]
+#define A8 _av[7]
+#define A9 _av[8]
+#define A10 _av[9]
+
+#endif /*_SWI_CPP_H*/
generated by cgit v0.12 at 2024-07-07 19:07:52 (GMT)