clipspyx-ffi 0.1.0__tar.gz

clipspyx_ffi-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: clipspyx-ffi
+Version: 0.1.0
+Summary: Shared CFFI build infrastructure for clipspyx
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/inferal-oss/clipspyx
+Project-URL: Repository, https://github.com/inferal-oss/clipspyx
+Requires-Python: >=3.10
+Requires-Dist: cffi>=1.0.0

clipspyx_ffi-0.1.0/clipspyx_ffi/__init__.py

@@ -0,0 +1,5 @@
+"""Shared CFFI build infrastructure for clipspyx."""
+
+from clipspyx_ffi.build import make_ffibuilder, resolve_clips_source
+
+__all__ = ["make_ffibuilder", "resolve_clips_source"]

clipspyx_ffi-0.1.0/clipspyx_ffi/build.py

@@ -0,0 +1,285 @@
+# Copyright (c) 2016-2025, Matteo Cafasso
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
+# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+# OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+# OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import glob
+import hashlib
+import os
+import re
+import subprocess
+import sys
+
+
+def _subdir_for_branch(branch: str) -> str:
+    """Return subdirectory name for a CLIPS branch.
+
+    Known branches like clips-64x map to '64x'; arbitrary names
+    are hashed to an 8-char hex prefix.
+    """
+    prefix = "clips-"
+    if branch.startswith(prefix):
+        return branch[len(prefix):]
+    return hashlib.sha256(branch.encode()).hexdigest()[:8]
+
+
+def _find_repo_root() -> str | None:
+    """Find the git repository root using git rev-parse.
+
+    Returns None if not inside a git repository.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True, text=True, check=True)
+        return result.stdout.strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+def resolve_clips_source(default_branch=None):
+    """Resolve CLIPS C source directory.
+
+    Priority:
+    1. CLIPS_SOURCE_DIR env var - arbitrary checkout path
+    2. CLIPS_BRANCH env var - checkout that orphan branch
+    3. default_branch argument
+    4. Default - auto-checkout clips-64x branch
+
+    Each branch gets its own subdirectory under .clips-source/<suffix>/
+    so multiple source checkouts coexist without switching.
+    """
+    # Priority 1: explicit source directory
+    src_dir = os.environ.get("CLIPS_SOURCE_DIR")
+    if src_dir:
+        src_dir = os.path.abspath(src_dir)
+        if not os.path.isdir(src_dir):
+            raise FileNotFoundError(
+                f"CLIPS_SOURCE_DIR={src_dir} does not exist")
+        return src_dir
+
+    # Priority 2/3/4: checkout from local orphan branch
+    branch = os.environ.get("CLIPS_BRANCH", default_branch or "clips-64x")
+    repo_root = _find_repo_root()
+    if repo_root is None:
+        raise FileNotFoundError(
+            "Not inside a git repository. "
+            "Set CLIPS_SOURCE_DIR to point to CLIPS source.")
+
+    base_dir = os.path.join(repo_root, ".clips-source")
+    subdir = _subdir_for_branch(branch)
+    checkout_dir = os.path.join(base_dir, subdir)
+
+    # Migration: if .clips-source is an old single-worktree layout, remove it
+    git_file = os.path.join(base_dir, ".git")
+    if os.path.isfile(git_file):
+        import shutil
+        subprocess.run(
+            ["git", "worktree", "remove", base_dir],
+            capture_output=True, text=True, cwd=repo_root)
+        if os.path.exists(base_dir):
+            shutil.rmtree(base_dir, ignore_errors=True)
+        subprocess.run(
+            ["git", "worktree", "prune"],
+            capture_output=True, text=True, cwd=repo_root)
+
+    # Already checked out: return immediately
+    if os.path.isdir(checkout_dir):
+        return checkout_dir
+
+    # Create parent directory and prune stale worktrees
+    os.makedirs(base_dir, exist_ok=True)
+    subprocess.run(
+        ["git", "worktree", "prune"],
+        capture_output=True, text=True, cwd=repo_root)
+
+    # Attempt git worktree checkout
+    try:
+        subprocess.run(
+            ["git", "worktree", "add", checkout_dir, branch],
+            check=True, capture_output=True, text=True,
+            cwd=repo_root)
+    except subprocess.CalledProcessError as e:
+        # Check if branch exists locally
+        result = subprocess.run(
+            ["git", "branch", "--list", branch],
+            capture_output=True, text=True, cwd=repo_root)
+        if not result.stdout.strip():
+            # Branch missing locally — try fetching from origin
+            # (common when installed as a git dependency: uv only clones the default branch)
+            print(f"  Branch '{branch}' not found locally, fetching from origin...")
+            fetch = subprocess.run(
+                ["git", "fetch", "origin", f"{branch}:{branch}"],
+                capture_output=True, text=True, cwd=repo_root)
+            if fetch.returncode == 0:
+                print(f"  Fetched '{branch}' from origin")
+                try:
+                    subprocess.run(
+                        ["git", "worktree", "add", checkout_dir, branch],
+                        check=True, capture_output=True, text=True,
+                        cwd=repo_root)
+                    return checkout_dir
+                except subprocess.CalledProcessError as e2:
+                    raise FileNotFoundError(
+                        f"Cannot checkout CLIPS source from branch '{branch}': "
+                        f"{e2.stderr.strip()}")
+            else:
+                print(
+                    f"Error: Branch '{branch}' not found locally or on origin.\n"
+                    f"Run: ./scripts/sync-svn.sh 64x\n"
+                    f"Or set CLIPS_SOURCE_DIR to point to CLIPS source.",
+                    file=sys.stderr)
+        raise FileNotFoundError(
+            f"Cannot checkout CLIPS source from branch '{branch}': "
+            f"{e.stderr.strip()}")
+
+    return checkout_dir
+
+
+def _detect_clips_major(clips_src: str) -> int:
+    """Detect CLIPS major version from constant.h in the source directory."""
+    constant_h = os.path.join(clips_src, "constant.h")
+    if os.path.exists(constant_h):
+        with open(constant_h) as f:
+            m = re.search(r'#define\s+VERSION_STRING\s+"(\d+)', f.read())
+            if m:
+                return int(m.group(1))
+    return 6
+
+
+CLIPS_SOURCE = """
+#include <clips.h>
+
+const int CLIPSPYX_CLIPS_MAJOR = CLIPS_MAJOR;
+
+/* CLIPS 7.0 renamed DeftemplateGet/SetWatch -> DeftemplateGet/SetWatchFacts. */
+#if CLIPS_MAJOR >= 7
+#define DeftemplateGetWatch DeftemplateGetWatchFacts
+#define DeftemplateSetWatch DeftemplateSetWatchFacts
+
+#include "tabledef.h"
+#include "tablebsc.h"
+#endif
+
+/* Return true if the template is implied. */
+bool ImpliedDeftemplate(Deftemplate *template)
+{
+    return template->implied;
+}
+
+#if CLIPS_MAJOR >= 7
+/* Return the row count for a deftable. */
+unsigned long DeftableRowCount(Deftable *table)
+{
+    return table->rowCount;
+}
+
+/* Return the column count for a deftable. */
+unsigned long DeftableColumnCount(Deftable *table)
+{
+    return table->columnCount;
+}
+#endif
+
+/* User Defined Functions support. */
+static void python_function(Environment *env, UDFContext *udfc, UDFValue *out);
+
+int DefinePythonFunction(Environment *environment)
+{
+    return AddUDF(
+        environment, "python-function",
+        NULL, UNBOUNDED, UNBOUNDED, NULL,
+        python_function, "python_function", NULL);
+}
+"""
+
+
+def make_ffibuilder(module_name="clipspyx._clipspyx",
+                    default_branch=None,
+                    cdef_dir=None):
+    """Create and configure a CFFI FFIBuilder for CLIPS.
+
+    Args:
+        module_name: Dotted module name for the compiled extension
+            (e.g. "clipspyx_ffi_64x._clipspyx").
+        default_branch: Default CLIPS source branch to use if neither
+            CLIPS_SOURCE_DIR nor CLIPS_BRANCH is set.
+        cdef_dir: Directory containing .cdef files. Defaults to this
+            package's own directory.
+
+    Returns:
+        Configured cffi.FFI instance ready for compilation.
+    """
+    from cffi import FFI
+
+    clips_src = resolve_clips_source(default_branch)
+
+    # setuptools requires relative paths; compute relative to CWD
+    # (which is the package directory during build)
+    clips_src_rel = os.path.relpath(clips_src)
+
+    # Collect all .c files from CLIPS source (as relative paths)
+    clips_c_files = sorted(glob.glob(os.path.join(clips_src_rel, "*.c")))
+    if not clips_c_files:
+        raise FileNotFoundError(
+            f"No .c files found in {clips_src}. "
+            f"Is this a valid CLIPS source directory?")
+
+    clips_major = _detect_clips_major(clips_src)
+
+    ffibuilder = FFI()
+
+    if sys.platform == "win32":
+        extra_compile_args = [f"/DCLIPS_MAJOR={clips_major}"]
+        extra_link_args = []
+    else:
+        extra_compile_args = ["-std=c99", "-O2", "-fno-strict-aliasing",
+                              f"-DCLIPS_MAJOR={clips_major}"]
+        extra_link_args = ["-lm"]
+
+    ffibuilder.set_source(
+        module_name,
+        CLIPS_SOURCE,
+        sources=clips_c_files,
+        include_dirs=[clips_src_rel],
+        extra_compile_args=extra_compile_args,
+        extra_link_args=extra_link_args)
+
+    # Read CFFI definitions from the .cdef files
+    if cdef_dir is None:
+        cdef_dir = os.path.dirname(os.path.abspath(__file__))
+
+    cdef_path = os.path.join(cdef_dir, "clips.cdef")
+    with open(cdef_path) as cdef_file:
+        ffibuilder.cdef(cdef_file.read())
+
+    if clips_major >= 7:
+        cdef_70x_path = os.path.join(cdef_dir, "clips-70x.cdef")
+        with open(cdef_70x_path) as cdef_70x_file:
+            ffibuilder.cdef(cdef_70x_file.read())
+
+    return ffibuilder

clipspyx_ffi-0.1.0/clipspyx_ffi/clips-70x.cdef

@@ -0,0 +1,56 @@
+/**********************/
+/* CLIPS 7.0 Deftable */
+/**********************/
+
+typedef struct deftable Deftable;
+
+Deftable *FindDeftable(Environment *, const char *);
+Deftable *GetNextDeftable(Environment *, Deftable *);
+const char *DeftableName(Deftable *);
+const char *DeftableModule(Deftable *);
+const char *DeftablePPForm(Deftable *);
+bool DeftableIsDeletable(Deftable *);
+bool Undeftable(Deftable *, Environment *);
+void GetDeftableList(Environment *, CLIPSValue *, Defmodule *);
+void GetTableValue(Environment *, Deftable *, unsigned int, unsigned int,
+                   UDFValue *);
+unsigned long DeftableRowCount(Deftable *);
+unsigned long DeftableColumnCount(Deftable *);
+
+/*******************/
+/* CLIPS 7.0 Goals */
+/*******************/
+
+Fact *GetNextGoal(Environment *, Fact *);
+Fact *FindIndexedGoal(Environment *, long long);
+RetractError RetractAllGoals(Environment *);
+bool GetGoalListChanged(Environment *);
+void SetGoalListChanged(Environment *, bool);
+void Goals(Environment *, const char *, Defmodule *,
+           long long, long long, long long);
+
+/*************************************/
+/* CLIPS 7.0 Deftemplate Watch Goals */
+/*************************************/
+
+bool DeftemplateGetWatchGoals(Deftemplate *);
+void DeftemplateSetWatchGoals(Deftemplate *, bool);
+
+/*************************************/
+/* CLIPS 7.0 Deftemplate Inheritance */
+/*************************************/
+
+bool HasSupertemplate(Deftemplate *, Deftemplate *);
+bool CanMatchGoal(Deftemplate *);
+
+/*********************************/
+/* CLIPS 7.0 Certainty Factors  */
+/*********************************/
+
+short GetFactCertaintyFactor(Fact *);
+
+/*********************************/
+/* CLIPS 7.0 FMUpdate           */
+/*********************************/
+
+Fact *FMUpdate(FactModifier *);

clipspyx_ffi-0.1.0/clipspyx_ffi/clips.cdef

@@ -0,0 +1,639 @@
+typedef enum {
+    LE_NO_ERROR,
+    LE_OPEN_FILE_ERROR,
+    LE_PARSING_ERROR
+} LoadError;
+
+typedef enum {
+    EE_NO_ERROR,
+    EE_PARSING_ERROR,
+    EE_PROCESSING_ERROR
+} EvalError;
+
+typedef enum {
+    BE_NO_ERROR,
+    BE_COULD_NOT_BUILD_ERROR,
+    BE_CONSTRUCT_NOT_FOUND_ERROR,
+    BE_PARSING_ERROR,
+} BuildError;
+
+typedef enum {
+    ASE_NO_ERROR,
+    ASE_NULL_POINTER_ERROR,
+    ASE_PARSING_ERROR,
+    ASE_COULD_NOT_ASSERT_ERROR,
+    ASE_RULE_NETWORK_ERROR
+} AssertStringError;
+
+typedef enum {
+    RE_NO_ERROR,
+    RE_NULL_POINTER_ERROR,
+    RE_COULD_NOT_RETRACT_ERROR,
+    RE_RULE_NETWORK_ERROR
+} RetractError;
+
+typedef enum {
+    MIE_NO_ERROR,
+    MIE_NULL_POINTER_ERROR,
+    MIE_PARSING_ERROR,
+    MIE_COULD_NOT_CREATE_ERROR,
+    MIE_RULE_NETWORK_ERROR
+} MakeInstanceError;
+
+typedef enum {
+    UIE_NO_ERROR,
+    UIE_NULL_POINTER_ERROR,
+    UIE_COULD_NOT_DELETE_ERROR,
+    UIE_DELETED_ERROR,
+    UIE_RULE_NETWORK_ERROR
+} UnmakeInstanceError;
+
+typedef enum {
+    FBE_NO_ERROR,
+    FBE_NULL_POINTER_ERROR,
+    FBE_DEFTEMPLATE_NOT_FOUND_ERROR,
+    FBE_IMPLIED_DEFTEMPLATE_ERROR,
+    FBE_COULD_NOT_ASSERT_ERROR,
+    FBE_RULE_NETWORK_ERROR
+} FactBuilderError;
+
+typedef enum {
+    FME_NO_ERROR,
+    FME_NULL_POINTER_ERROR,
+    FME_RETRACTED_ERROR,
+    FME_IMPLIED_DEFTEMPLATE_ERROR,
+    FME_COULD_NOT_MODIFY_ERROR,
+    FME_RULE_NETWORK_ERROR
+} FactModifierError;
+
+typedef enum {
+    PSE_NO_ERROR,
+    PSE_NULL_POINTER_ERROR,
+    PSE_INVALID_TARGET_ERROR,
+    PSE_SLOT_NOT_FOUND_ERROR,
+    PSE_TYPE_ERROR,
+    PSE_RANGE_ERROR,
+    PSE_ALLOWED_VALUES_ERROR,
+    PSE_CARDINALITY_ERROR,
+    PSE_ALLOWED_CLASSES_ERROR
+} PutSlotError;
+
+typedef enum {
+    GSE_NO_ERROR,
+    GSE_NULL_POINTER_ERROR,
+    GSE_INVALID_TARGET_ERROR,
+    GSE_SLOT_NOT_FOUND_ERROR
+} GetSlotError;
+
+typedef enum {
+    LOCAL_SAVE,
+    VISIBLE_SAVE
+} SaveScope;
+
+typedef enum {
+    NO_DEFAULT,
+    STATIC_DEFAULT,
+    DYNAMIC_DEFAULT
+} DefaultType;
+
+typedef enum {
+    IBE_NO_ERROR,
+    IBE_NULL_POINTER_ERROR,
+    IBE_DEFCLASS_NOT_FOUND_ERROR,
+    IBE_COULD_NOT_CREATE_ERROR,
+    IBE_RULE_NETWORK_ERROR
+} InstanceBuilderError;
+
+typedef enum {
+    IME_NO_ERROR,
+    IME_NULL_POINTER_ERROR,
+    IME_DELETED_ERROR,
+    IME_COULD_NOT_MODIFY_ERROR,
+    IME_RULE_NETWORK_ERROR
+} InstanceModifierError;
+
+typedef enum {
+    CONVENIENCE_MODE,
+    CONSERVATION_MODE
+} ClassDefaultsMode;
+
+typedef enum {
+    WHEN_DEFINED,
+    WHEN_ACTIVATED,
+    EVERY_CYCLE
+} SalienceEvaluationType;
+
+typedef enum {
+    DEPTH_STRATEGY,
+    BREADTH_STRATEGY,
+    LEX_STRATEGY,
+    MEA_STRATEGY,
+    COMPLEXITY_STRATEGY,
+    SIMPLICITY_STRATEGY,
+    RANDOM_STRATEGY
+} StrategyType;
+
+typedef enum {
+    VERBOSE,
+    SUCCINCT,
+    TERSE
+} Verbosity;
+
+typedef enum {
+    FCBE_NO_ERROR,
+    FCBE_NULL_POINTER_ERROR,
+    FCBE_FUNCTION_NOT_FOUND_ERROR,
+    FCBE_INVALID_FUNCTION_ERROR,
+    FCBE_ARGUMENT_COUNT_ERROR,
+    FCBE_ARGUMENT_TYPE_ERROR,
+    FCBE_PROCESSING_ERROR
+} FunctionCallBuilderError;
+
+typedef enum {
+    AUE_NO_ERROR,
+    AUE_MIN_EXCEEDS_MAX_ERROR,
+    AUE_FUNCTION_NAME_IN_USE_ERROR,
+    AUE_INVALID_ARGUMENT_TYPE_ERROR,
+    AUE_INVALID_RETURN_TYPE_ERROR
+} AddUDFError;
+
+typedef enum  {
+    FLOAT_BIT = 1,
+    INTEGER_BIT = 2,
+    SYMBOL_BIT = 4,
+    STRING_BIT = 8,
+    MULTIFIELD_BIT = 16,
+    EXTERNAL_ADDRESS_BIT = 32,
+    FACT_ADDRESS_BIT = 64,
+    INSTANCE_ADDRESS_BIT = 128,
+    INSTANCE_NAME_BIT = 256,
+    VOID_BIT = 512,
+    BOOLEAN_BIT = 1024
+} CLIPSType;
+
+typedef struct environment Environment;
+typedef struct defrule Defrule;
+typedef struct fact Fact;
+typedef struct deftemplate Deftemplate;
+typedef struct deffacts Deffacts;
+typedef struct instance Instance;
+typedef struct defclass Defclass;
+typedef struct definstances Definstances;
+typedef struct deffunction Deffunction;
+typedef struct defgeneric Defgeneric;
+typedef struct defmodule Defmodule;
+typedef struct defglobal Defglobal;
+typedef struct activation Activation;
+typedef struct clipsValue CLIPSValue;
+typedef struct factBuilder FactBuilder;
+typedef struct factModifier FactModifier;
+typedef struct instanceModifier InstanceModifier;
+typedef struct instanceBuilder InstanceBuilder;
+typedef struct multifieldBuilder MultifieldBuilder;
+typedef struct functionCallBuilder FunctionCallBuilder;
+
+typedef struct stringBuilder {
+    char *contents;
+    size_t length;
+    ...;
+} StringBuilder;
+
+typedef struct typeHeader {
+    unsigned short type;
+} TypeHeader;
+
+typedef struct clipsLexeme {
+    TypeHeader header;
+    const char *contents;
+    ...;
+} CLIPSLexeme;
+
+typedef struct clipsInteger {
+    TypeHeader header;
+    long long contents;
+    ...;
+} CLIPSInteger;
+
+typedef struct clipsFloat {
+    TypeHeader header;
+    double contents;
+    ...;
+} CLIPSFloat;
+
+typedef struct multifield {
+    TypeHeader header;
+    size_t length;
+    CLIPSValue contents[1];
+    ...;
+} Multifield;
+
+typedef struct clipsExternalAddress {
+    TypeHeader header;
+    void *contents;
+    ...;
+} CLIPSExternalAddress;
+
+typedef struct clipsVoid {
+    TypeHeader header;
+} CLIPSVoid;
+
+typedef struct clipsValue {
+    union {
+        void *value;
+        TypeHeader *header;
+        CLIPSLexeme *lexemeValue;
+        CLIPSFloat *floatValue;
+        CLIPSInteger *integerValue;
+        CLIPSVoid *voidValue;
+        Fact *factValue;
+        Instance *instanceValue;
+        Multifield *multifieldValue;
+        CLIPSExternalAddress *externalAddressValue;
+    };
+} CLIPSValue;
+
+typedef struct udfContext {
+   Environment *environment;
+   void *context;
+   ...;
+} UDFContext;
+
+typedef struct udfValue {
+    union {
+        void *value;
+        TypeHeader *header;
+        CLIPSLexeme *lexemeValue;
+        CLIPSFloat *floatValue;
+        CLIPSInteger *integerValue;
+        CLIPSVoid *voidValue;
+        Multifield *multifieldValue;
+        Fact *factValue;
+        Instance *instanceValue;
+        CLIPSExternalAddress *externalAddressValue;
+    };
+    size_t begin;
+    size_t range;
+} UDFValue;
+
+/*****************/
+/* Version Query */
+/*****************/
+
+const int CLIPSPYX_CLIPS_MAJOR;
+
+/***************/
+/* Environment */
+/***************/
+
+Environment *CreateEnvironment();
+bool DestroyEnvironment(Environment *);
+BuildError Build(Environment *, const char *);
+EvalError Eval(Environment *, const char *, CLIPSValue *);
+bool Clear(Environment *);
+void Reset(Environment *);
+bool BatchStar(Environment *, const char *);
+bool Save(Environment *, const char *);
+bool Bsave(Environment *, const char *);
+LoadError Load(Environment *, const char *);
+bool Bload(Environment *, const char *);
+
+/****************************/
+/* Primitive Types Creation */
+/****************************/
+
+CLIPSLexeme *CreateSymbol(Environment *, const char *);
+CLIPSLexeme *CreateString(Environment *, const char *);
+CLIPSLexeme *CreateInstanceName(Environment *, const char *);
+CLIPSLexeme *CreateBoolean(Environment *, bool);
+CLIPSLexeme *FalseSymbol(Environment *);
+CLIPSLexeme *TrueSymbol(Environment *);
+CLIPSInteger *CreateInteger(Environment *, long long);
+CLIPSFloat *CreateFloat(Environment *, double);
+Multifield *EmptyMultifield(Environment *);
+MultifieldBuilder *CreateMultifieldBuilder(Environment *, size_t);
+Multifield *MBCreate(MultifieldBuilder *);
+void MBReset(MultifieldBuilder *);
+void MBDispose(MultifieldBuilder *);
+void MBAppend(MultifieldBuilder *, CLIPSValue *);
+CLIPSVoid *VoidConstant(Environment *);
+CLIPSExternalAddress *CreateCExternalAddress(Environment *, void *);
+StringBuilder *CreateStringBuilder(Environment *, size_t);
+void SBReset(StringBuilder *);
+void SBDispose(StringBuilder *);
+
+/*********/
+/* Facts */
+/*********/
+
+void RetainFact(Fact *);
+void ReleaseFact(Fact *);
+Fact *AssertString(Environment *, const char *);
+AssertStringError GetAssertStringError(Environment *);
+RetractError Retract(Fact *);
+FactBuilder *CreateFactBuilder(Environment *, const char *);
+Fact *FBAssert(FactBuilder *);
+void FBDispose(FactBuilder *);
+FactBuilderError FBSetDeftemplate(FactBuilder *, const char *);
+void FBAbort(FactBuilder *);
+FactBuilderError FBError(Environment *);
+FactModifier *CreateFactModifier(Environment *, Fact *);
+Fact *FMModify(FactModifier *);
+void FMDispose(FactModifier *);
+FactModifierError FMSetFact(FactModifier *, Fact *);
+void FMAbort(FactModifier *);
+FactModifierError FMError(Environment *);
+RetractError RetractAllFacts(Environment *);
+bool FactExistp(Fact *);
+Deftemplate *FactDeftemplate(Fact *);
+long long FactIndex(Fact *);
+const char *DeftemplateName(Deftemplate *);
+bool ImpliedDeftemplate(Deftemplate *);
+bool DeftemplateIsDeletable(Deftemplate *);
+bool Undeftemplate(Deftemplate *, Environment *);
+void FactSlotNames(Fact *, CLIPSValue *);
+void DeftemplateSlotNames(Deftemplate *, CLIPSValue *);
+Deftemplate *FindDeftemplate(Environment *, const char *);
+Fact *GetNextFact(Environment *, Fact *);
+Fact *GetNextFactInTemplate(Deftemplate *, Fact *);
+bool LoadFacts(Environment *, const char *);
+bool LoadFactsFromString(Environment *, const char *, size_t);
+bool SaveFacts(Environment *, const char *, SaveScope);
+const char *DeftemplatePPForm(Deftemplate *);
+bool DeftemplateSlotAllowedValues(Deftemplate *, const char *, CLIPSValue *);
+bool DeftemplateSlotCardinality(Deftemplate *, const char *, CLIPSValue *);
+bool DeftemplateSlotRange(Deftemplate *, const char *, CLIPSValue *);
+bool DeftemplateSlotDefaultValue(Deftemplate *, const char *, CLIPSValue *);
+bool DeftemplateSlotTypes(Deftemplate *, const char *, CLIPSValue *);
+bool DeftemplateSlotExistP(Deftemplate *, const char *);
+bool DeftemplateSlotMultiP(Deftemplate *, const char *);
+bool DeftemplateSlotSingleP(Deftemplate *, const char *);
+DefaultType DeftemplateSlotDefaultP(Deftemplate *, const char *);
+bool GetFactDuplication(Environment *);
+bool SetFactDuplication(Environment *, bool);
+const char *DeftemplateModule(Deftemplate *);
+Deftemplate *GetNextDeftemplate(Environment *, Deftemplate *);
+bool DeftemplateGetWatch(Deftemplate *);
+void DeftemplateSetWatch(Deftemplate *, bool);
+void FactPPForm(Fact *, StringBuilder *, bool);
+Deffacts *FindDeffacts(Environment *, const char *);
+Deffacts *GetNextDeffacts(Environment *, Deffacts *);
+const char *DeffactsModule(Deffacts *);
+const char *DeffactsName(Deffacts *);
+const char *DeffactsPPForm(Deffacts *);
+bool DeffactsIsDeletable(Deffacts *);
+bool Undeffacts(Deffacts *, Environment *);
+
+/*************/
+/* Instances */
+/*************/
+
+void RetainInstance(Instance *);
+void ReleaseInstance(Instance *);
+Instance *MakeInstance(Environment *, const char *);
+MakeInstanceError GetMakeInstanceError(Environment *);
+UnmakeInstanceError UnmakeInstance(Instance *);
+UnmakeInstanceError DeleteInstance(Instance *);
+InstanceBuilder *CreateInstanceBuilder(Environment *, const char *);
+Instance *IBMake(InstanceBuilder *, const char *);
+void IBDispose(InstanceBuilder *);
+InstanceBuilderError IBSetDefclass(InstanceBuilder *, const char *);
+InstanceBuilderError IBError(Environment *);
+InstanceModifier *CreateInstanceModifier(Environment *, Instance *);
+Instance *IMModify(InstanceModifier *);
+void IMDispose(InstanceModifier *);
+InstanceModifierError IMSetInstance(InstanceModifier *, Instance *);
+InstanceModifierError IMError(Environment *);
+Defclass *FindDefclass(Environment *, const char *);
+Defclass *GetNextDefclass(Environment *, Defclass *);
+const char *DefclassModule(Defclass *);
+const char *DefclassName(Defclass *);
+const char *DefclassPPForm(Defclass *);
+void ClassSlots(Defclass *, CLIPSValue *, bool);
+void ClassSubclasses(Defclass *, CLIPSValue *, bool);
+void ClassSuperclasses(Defclass *, CLIPSValue *, bool);
+bool DefclassIsDeletable(Defclass *);
+bool Undefclass(Defclass *, Environment *);
+bool DefclassGetWatchInstances(Defclass *);
+bool DefclassGetWatchSlots(Defclass *);
+void DefclassSetWatchInstances(Defclass *, bool);
+void DefclassSetWatchSlots(Defclass *, bool);
+bool ClassAbstractP(Defclass *);
+bool ClassReactiveP(Defclass *);
+bool SubclassP(Defclass *, Defclass *);
+bool SuperclassP(Defclass *, Defclass *);
+bool SlotAllowedClasses(Defclass *, const char *, CLIPSValue *);
+bool SlotAllowedValues(Defclass *, const char *, CLIPSValue *);
+bool SlotCardinality(Defclass *, const char *, CLIPSValue *);
+bool SlotDefaultValue(Defclass *, const char *, CLIPSValue *);
+bool SlotFacets(Defclass *, const char *, CLIPSValue *);
+bool SlotRange(Defclass *, const char *, CLIPSValue *);
+bool SlotSources(Defclass *, const char *, CLIPSValue *);
+bool SlotTypes(Defclass *, const char *, CLIPSValue *);
+bool SlotDirectAccessP(Defclass *, const char *);
+bool SlotExistP(Defclass *, const char *, bool);
+bool SlotInitableP(Defclass *, const char *);
+bool SlotPublicP(Defclass *, const char *);
+bool SlotWritableP(Defclass *, const char *);
+ClassDefaultsMode GetClassDefaultsMode(Environment *);
+ClassDefaultsMode SetClassDefaultsMode(Environment *, ClassDefaultsMode);
+Instance *FindInstance(Environment *, Defmodule *, const char *, bool);
+Instance *GetNextInstance(Environment *, Instance *);
+Instance *GetNextInstanceInClass(Defclass *, Instance *);
+Defclass *InstanceClass(Instance *);
+const char *InstanceName(Instance *);
+void InstancePPForm(Instance *, StringBuilder *);
+void Send(Environment *, CLIPSValue *, const char *,
+          const char *, CLIPSValue *);
+unsigned FindDefmessageHandler(Defclass *, const char *, const char *);
+unsigned GetNextDefmessageHandler(Defclass *, unsigned);
+const char *DefmessageHandlerName(Defclass *, unsigned);
+const char *DefmessageHandlerPPForm(Defclass *, unsigned);
+const char *DefmessageHandlerType(Defclass *, unsigned);
+bool DefmessageHandlerIsDeletable(Defclass *, unsigned);
+bool UndefmessageHandler(Defclass *, unsigned, Environment *);
+bool DefmessageHandlerGetWatch(Defclass *, unsigned);
+void DefmessageHandlerSetWatch(Defclass *, unsigned, bool);
+Definstances *FindDefinstances(Environment *, const char *);
+Definstances *GetNextDefinstances(Environment *, Definstances *);
+const char *DefinstancesModule(Definstances *);
+const char *DefinstancesName(Definstances *);
+const char *DefinstancesPPForm(Definstances *);
+bool DefinstancesIsDeletable(Definstances *);
+bool Undefinstances(Definstances *, Environment *);
+bool GetInstancesChanged(Environment *);
+void SetInstancesChanged(Environment *, bool);
+long BinaryLoadInstances(Environment *, const char *);
+long LoadInstances(Environment *, const char *);
+long LoadInstancesFromString(Environment *, const char *, size_t);
+long RestoreInstances(Environment *, const char *);
+long RestoreInstancesFromString(Environment *, const char *, size_t);
+long BinarySaveInstances(Environment *, const char *, SaveScope);
+long SaveInstances(Environment *, const char *, SaveScope);
+
+/*********/
+/* Slots */
+/*********/
+
+PutSlotError IBPutSlot(InstanceBuilder *, const char *, CLIPSValue *);
+PutSlotError IMPutSlot(InstanceModifier *, const char *, CLIPSValue *);
+PutSlotError FBPutSlot(FactBuilder *, const char *, CLIPSValue *);
+PutSlotError FMPutSlot(FactModifier *, const char *, CLIPSValue *);
+GetSlotError GetFactSlot(Fact *, const char *, CLIPSValue *);
+GetSlotError DirectGetSlot(Instance *, const char *, CLIPSValue *);
+
+/**********/
+/* Agenda */
+/**********/
+
+Activation *GetNextActivation(Environment *, Activation *);
+const char *ActivationRuleName(Activation *);
+void ActivationPPForm(Activation *, StringBuilder *);
+int ActivationGetSalience(Activation *);
+int ActivationSetSalience(Activation *, int);
+void RefreshAgenda(Defmodule *);
+void RefreshAllAgendas(Environment *);
+void ReorderAgenda(Defmodule *);
+void ReorderAllAgendas(Environment *);
+void DeleteActivation(Activation *);
+bool GetAgendaChanged(Environment *);
+void SetAgendaChanged(Environment *, bool);
+SalienceEvaluationType GetSalienceEvaluation(Environment *);
+SalienceEvaluationType SetSalienceEvaluation(Environment *,
+                                             SalienceEvaluationType);
+StrategyType GetStrategy(Environment *);
+StrategyType SetStrategy(Environment *, StrategyType);
+Defrule *FindDefrule(Environment *, const char *);
+Defrule *GetNextDefrule(Environment *, Defrule *);
+const char *DefruleModule(Defrule *);
+const char *DefruleName(Defrule *);
+const char *DefrulePPForm(Defrule *);
+bool DefruleIsDeletable(Defrule *);
+bool Undefrule(Defrule *, Environment *);
+bool DefruleGetWatchActivations(Defrule *);
+bool DefruleGetWatchFirings(Defrule *);
+void DefruleSetWatchActivations(Defrule *, bool);
+void DefruleSetWatchFirings(Defrule *, bool);
+bool DefruleHasBreakpoint(Defrule *);
+bool RemoveBreak(Defrule *);
+void SetBreak(Defrule *);
+void Matches(Defrule *, Verbosity, CLIPSValue *);
+void Refresh(Defrule *);
+void ClearFocusStack(Environment *);
+void Focus(Defmodule *);
+Defmodule *PopFocus(Environment *);
+Defmodule *GetFocus(Environment *);
+void DeleteAllActivations(Defmodule *);
+long long Run(Environment *, long long);
+
+/*********************/
+/* Modules & Globals */
+/*********************/
+
+Defmodule *FindDefmodule(Environment *, const char *);
+Defmodule *GetNextDefmodule(Environment *, Defmodule *);
+const char *DefmoduleName(Defmodule *);
+const char *DefmodulePPForm(Defmodule *);
+Defmodule *GetCurrentModule(Environment *);
+Defmodule *SetCurrentModule(Environment *, Defmodule *);
+Defglobal *FindDefglobal(Environment *, const char *);
+Defglobal *GetNextDefglobal(Environment *, Defglobal *);
+const char *DefglobalModule(Defglobal *);
+const char *DefglobalName(Defglobal *);
+const char *DefglobalPPForm(Defglobal *);
+void DefglobalValueForm(Defglobal *, StringBuilder *);
+void DefglobalGetValue(Defglobal *, CLIPSValue *);
+void DefglobalSetValue(Defglobal *, CLIPSValue *);
+bool DefglobalIsDeletable(Defglobal *);
+bool Undefglobal(Defglobal *, Environment *);
+bool DefglobalGetWatch(Defglobal *);
+void DefglobalSetWatch(Defglobal *, bool);
+bool GetGlobalsChanged(Environment *);
+void SetGlobalsChanged(Environment *, bool);
+bool GetResetGlobals(Environment *);
+bool SetResetGlobals(Environment *, bool);
+
+/*********************************/
+/* Functions, Generics & Methods */
+/*********************************/
+
+Deffunction *FindDeffunction(Environment *, const char *);
+Deffunction *GetNextDeffunction(Environment *, Deffunction *);
+const char *DeffunctionModule(Deffunction *);
+const char *DeffunctionName(Deffunction *);
+const char *DeffunctionPPForm(Deffunction *);
+bool DeffunctionIsDeletable(Deffunction *);
+bool Undeffunction(Deffunction *, Environment *);
+bool DeffunctionGetWatch(Deffunction *);
+void DeffunctionSetWatch(Deffunction *, bool);
+Defgeneric *FindDefgeneric(Environment *, const char *);
+Defgeneric *GetNextDefgeneric(Environment *, Defgeneric *);
+const char *DefgenericModule(Defgeneric *);
+const char *DefgenericName(Defgeneric *);
+const char *DefgenericPPForm(Defgeneric *);
+bool DefgenericIsDeletable(Defgeneric *);
+bool Undefgeneric(Defgeneric *, Environment *);
+bool DefgenericGetWatch(Defgeneric *);
+void DefgenericSetWatch(Defgeneric *, bool);
+unsigned GetNextDefmethod(Defgeneric *, unsigned);
+void DefmethodDescription(Defgeneric *, unsigned, StringBuilder *);
+const char *DefmethodPPForm(Defgeneric *, unsigned);
+void GetMethodRestrictions(Defgeneric *, unsigned, CLIPSValue *);
+bool DefmethodIsDeletable(Defgeneric *, unsigned);
+bool Undefmethod(Defgeneric *, unsigned, Environment *);
+bool DefmethodGetWatch(Defgeneric *, unsigned);
+void DefmethodSetWatch(Defgeneric *, unsigned, bool);
+FunctionCallBuilder *CreateFunctionCallBuilder(Environment *, size_t);
+FunctionCallBuilderError FCBCall(FunctionCallBuilder *, const char *,
+                                 CLIPSValue *);
+void FCBReset(FunctionCallBuilder *);
+void FCBDispose(FunctionCallBuilder *);
+void FCBAppend(FunctionCallBuilder *, CLIPSValue *);
+
+/***********/
+/* Routers */
+/***********/
+
+typedef bool RouterQueryFunction(Environment *, const char *, void *);
+typedef void RouterWriteFunction(Environment *, const char *, const char *,
+                                 void *);
+typedef int RouterReadFunction(Environment *, const char *, void *);
+typedef int RouterUnreadFunction(Environment *, const char *, int, void *);
+typedef void RouterExitFunction(Environment *, int, void *);
+extern "Python" bool query_function(Environment *, const char *, void *);
+extern "Python" void write_function(Environment *, const char *, const char *,
+                                    void *);
+extern "Python" int read_function(Environment *, const char *, void *);
+extern "Python" int unread_function(Environment *, const char *, int, void *);
+extern "Python" void exit_function(Environment *, int, void *);
+bool AddRouter(Environment *, const char *, int, RouterQueryFunction *,
+               RouterWriteFunction *, RouterReadFunction *,
+               RouterUnreadFunction *, RouterExitFunction *, void *);
+bool DeleteRouter(Environment *, const char *);
+void WriteString(Environment *, const char *, const char *);
+void WriteCLIPSValue(Environment *, const char *, CLIPSValue *);
+int ReadRouter(Environment *, const char *);
+int UnreadRouter(Environment *, const char *, int);
+void ExitRouter(Environment *, int);
+bool ActivateRouter(Environment *, const char *);
+bool DeactivateRouter(Environment *, const char *);
+
+/**************************/
+/* User Defined Functions */
+/**************************/
+
+typedef void UserDefinedFunction(Environment *, UDFContext *, UDFValue *);
+AddUDFError AddUDF(Environment *, const char *, const char *,
+                   unsigned short, unsigned short, const char *,
+                   UserDefinedFunction *, const char *, void *);
+unsigned UDFArgumentCount(UDFContext *);
+bool UDFFirstArgument(UDFContext *, unsigned, UDFValue *);
+bool UDFNextArgument(UDFContext *, unsigned, UDFValue *);
+bool UDFNthArgument(UDFContext *, unsigned, unsigned, UDFValue *);
+bool UDFHasNextArgument(UDFContext *);
+void UDFThrowError(UDFContext *);
+void SetErrorValue(Environment *, TypeHeader *);
+void GetErrorFunction(Environment *, UDFContext *, UDFValue *);
+void ClearErrorValue(Environment *);
+int DefinePythonFunction(Environment *);
+extern "Python" static void python_function(Environment *, UDFContext *,
+                                            UDFValue *);

clipspyx_ffi-0.1.0/clipspyx_ffi.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: clipspyx-ffi
+Version: 0.1.0
+Summary: Shared CFFI build infrastructure for clipspyx
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/inferal-oss/clipspyx
+Project-URL: Repository, https://github.com/inferal-oss/clipspyx
+Requires-Python: >=3.10
+Requires-Dist: cffi>=1.0.0

clipspyx_ffi-0.1.0/clipspyx_ffi.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+clipspyx_ffi/__init__.py
+clipspyx_ffi/build.py
+clipspyx_ffi/clips-70x.cdef
+clipspyx_ffi/clips.cdef
+clipspyx_ffi.egg-info/PKG-INFO
+clipspyx_ffi.egg-info/SOURCES.txt
+clipspyx_ffi.egg-info/dependency_links.txt
+clipspyx_ffi.egg-info/requires.txt
+clipspyx_ffi.egg-info/top_level.txt

clipspyx_ffi-0.1.0/clipspyx_ffi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

clipspyx_ffi-0.1.0/clipspyx_ffi.egg-info/requires.txt

@@ -0,0 +1 @@
+cffi>=1.0.0

clipspyx_ffi-0.1.0/clipspyx_ffi.egg-info/top_level.txt

@@ -0,0 +1 @@
+clipspyx_ffi

clipspyx_ffi-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "clipspyx-ffi"
+version = "0.1.0"
+description = "Shared CFFI build infrastructure for clipspyx"
+license = "BSD-3-Clause"
+requires-python = ">=3.10"
+dependencies = ["cffi>=1.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/inferal-oss/clipspyx"
+Repository = "https://github.com/inferal-oss/clipspyx"
+
+[build-system]
+requires = ["setuptools>=42"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["clipspyx_ffi*"]
+
+[tool.setuptools.package-data]
+clipspyx_ffi = ["*.cdef"]

clipspyx_ffi-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+