IncludeCPP 4.6.0__py3-none-any.whl → 4.9.3__py3-none-any.whl

includecpp/CHANGELOG.md

@@ -1,5 +1,246 @@
 # IncludeCPP Changelog
 
+## v4.9.3 (2026-01-27)
+
+### New Features - Full Async/Await System
+
+#### Async Functions
+- **`async` function modifier**: Define async functions that return Futures
+  ```cssl
+  async define fetchData(string url) {
+      result = http.get(url);
+      return result;
+  }
+
+  // Calling returns Future immediately
+  future f = fetchData("http://example.com");
+  data = await f;
+  ```
+
+#### Await Keyword
+- **`await`**: Wait for async operations to complete
+  ```cssl
+  data = await asyncFunction();
+  result = await future;
+  ```
+
+#### Generator Functions with Yield
+- **`yield` statement**: Create lazy iterators
+  ```cssl
+  generator<int> define Range(int n) {
+      int i = 0;
+      while (i < n) {
+          yield i;
+          i = i + 1;
+      }
+  }
+
+  gen = Range(5);
+  while (gen.has_next()) {
+      printl(gen.next());  // 0, 1, 2, 3, 4
+  }
+  ```
+
+#### Async Module (`async::` / `Async::`)
+- **`async.run(func, *args)`**: Run function asynchronously, returns Future
+- **`async.stop(future)`**: Cancel async operation
+- **`async.wait(future, timeout?)`**: Wait for Future with optional timeout
+- **`async.all(futures, timeout?)`**: Wait for all Futures to complete
+- **`async.race(futures, timeout?)`**: Return first completed Future's result
+- **`async.sleep(ms)`**: Async sleep for milliseconds
+
+#### New Types
+- **`CSSLFuture`**: Represents result of async operation
+  - States: `pending`, `running`, `completed`, `cancelled`, `failed`
+  - Methods: `result()`, `is_done()`, `cancel()`, `then(callback)`
+- **`CSSLGenerator`**: Lazy iteration via yield
+  - Methods: `next()`, `has_next()`, `send(val)`, `to_list()`, `take(n)`, `skip(n)`
+- **`CSSLAsyncFunction`**: Wrapper for async-defined functions
+
+### Parser Enhancements
+- Added `async`, `yield`, `generator`, `future` keywords
+- Added `async` to function modifiers
+- Added `generator` and `future` to generic type keywords
+
+### Type Stubs
+- Updated `cssl_builtins.pyi` with full async type documentation
+- Added `CSSLFuture`, `CSSLGenerator`, `AsyncModule` stubs
+
+### Documentation
+- Added comprehensive Async/Await section to CSSL documentation
+- Added generator function examples and patterns
+
+---
+
+## v4.9.2 (2026-01-26)
+
+### New Features - Builtin Function Hooks & Introspection
+
+#### Builtin Function Hooks (`&builtin ++`)
+- **Hook into any builtin function** with append mode:
+  ```cssl
+  embedded define __hook_print(msg) &printl ++ {
+      printl("LOG: " + _result);  // _result has original's return value
+  }
+
+  // Now all printl calls trigger the hook AFTER original runs
+  printl("Hello");  // Prints: "Hello" then "LOG: null"
+  ```
+
+- **Append mode semantics**: Original runs first, then hook body executes
+- **`_result` variable**: Automatically contains the original function's return value
+- **`local::` references**: Access hook context variables
+  ```cssl
+  local::_result   // Original's return value
+  local::0         // First positional argument
+  local::_args     // All positional arguments
+  local::_kwargs   // All keyword arguments
+  ```
+
+#### New Builtins
+- **`destroy(target)`**: Destroy object and free memory
+  ```cssl
+  list data = [1, 2, 3];
+  destroy(data);  // Clears the list
+  ```
+
+- **`execute(code, context?)`**: Execute CSSL code string inline
+  ```cssl
+  result = execute("return 5 + 3;");  // Returns 8
+  execute("printl(name);", {"name": "World"});  // With context
+  ```
+
+#### Parser Enhancements
+- **Position syntax for hooks**: `&name[-1]` (places hook at specific position)
+- **`local::varname`** token type for accessing hooked function locals
+
+### Bug Fixes
+- Fixed infinite recursion when hook body calls the hooked builtin
+- Fixed `skip` keyword argument error in builtin hooks
+- Fixed hook execution order (original now runs before hook body in append mode)
+
+### Syntax Highlighting
+- Added `local::` reference highlighting
+- Added `_result`, `_args`, `_kwargs` special variable highlighting
+- Added `destroy` and `execute` builtin highlighting
+
+---
+
+## v4.9.0 (2026-01-25)
+
+### New Features - CSSL Language Enhancements
+
+#### Binary Data Types
+- **`bit`**: Single binary value (0 or 1)
+  ```cssl
+  bit flag = 1;
+  flag.switch();    // Toggle: 1 -> 0
+  flag.set(1);      // Set to 1
+  flag.clear();     // Set to 0
+  bit copy = flag.copy();
+  ```
+
+- **`byte`**: 8-bit value with `x^y` notation
+  ```cssl
+  byte b = 1^200;           // base^weight notation
+  printl(b.value());        // 200
+  printl(b.to_str());       // "11001000" (binary)
+  b.switch(7);              // Toggle bit 7
+  b.set(0, 1);              // Set bit 0 to 1
+  printl(b.info());         // Full info dict
+  byte r = b.reverse();     // Reverse bit order
+  ```
+
+- **`address`**: Memory reference (pointer-like)
+  ```cssl
+  string text = "Hello";
+  address addr = address(text);  // Get address
+  obj = addr.reflect();          // Dereference
+  obj = reflect(addr);           // Also works
+
+  // Use in functions
+  define useAddress() {
+      string val = reflect(addr);  // Access from anywhere
+  }
+  ```
+
+#### Pointer Syntax (`?`)
+- **`?name = obj`**: Create pointer to object (simple C-like syntax)
+- **`?name`**: Dereference pointer to get object
+  ```cssl
+  string text = "Hello";
+  ?ptr = text;                   // Create pointer
+
+  define usePointer() {
+      string val = ?ptr;         // Dereference: "Hello"
+      printl(val);
+  }
+  usePointer();
+  ```
+
+#### Memory Functions
+- **`address(obj)`**: Shortcut for `memory(obj).get("address")`
+- **`reflect(addr)`**: Dereference an address to get the original object
+- **`memory()`**: Now registers objects for later reflection
+
+#### Snapshot Assignment
+- **`%var = value`**: Direct snapshot assignment syntax
+  ```cssl
+  string greeting = "Hello";
+  %savedGreeting = greeting;
+  greeting = "Changed";
+  printl(%savedGreeting);  // "Hello"
+  ```
+
+### Bug Fixes
+- Fixed bit/byte method calls returning null in CSSL runtime
+- Fixed parser not recognizing bit/byte as type keywords
+- Fixed typed declarations for bit/byte/address types
+
+### Syntax Highlighting
+- Added `bit`, `byte`, `address` type highlighting
+- Updated `%variable` snapshot highlighting (% pink, variable blue-pink)
+
+---
+
+## v4.6.7 (2026-01-14)
+
+### New Features
+- **HomeServer**: Local storage server for modules, projects and files
+  - `includecpp server install` - Install and auto-start HomeServer
+  - `includecpp server start/stop` - Manual server control
+  - `includecpp server status` - Check server status
+  - `includecpp server upload/download` - File and project management
+  - `includecpp server list` - List stored items
+  - `includecpp server delete` - Remove items
+  - `includecpp server port` - Change server port
+  - `includecpp server deinstall` - Remove HomeServer completely
+- Server runs in background (no terminal window)
+- Auto-start support on Windows
+- SQLite database for metadata storage
+- Default port: 2007
+
+---
+
+## v4.6.6 (2026-01-14)
+
+### New Features
+- **ENUM support**: Expose C++ enums to Python via `ENUM(EnumName) CLASS { values... }` syntax
+- **Multiple SOURCE support**: `SOURCE(file1) && SOURCE(file2)` in .cp files
+- **FIELD_ARRAY support**: C-style arrays now properly bound as read-only `bytes` properties
+- Automatic detection of array fields in plugin command
+
+### Bug Fixes
+- Fixed signed/unsigned comparison warning from pybind11 enum bindings
+- Removed SIGNED_UNSIGNED from error catalog (was a warning, not error)
+- Fixed array fields causing `invalid array assignment` error
+- Version display now shows X.X format in build output
+
+### Breaking Changes
+- Array fields in structs are now read-only (accessible as `bytes`)
+
+---
+
 ## v4.3.2 (2026-01-08)
 
 ### New Features

includecpp/__init__.py

@@ -1,19 +1,91 @@
 from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
+import os
+import sys
+from pathlib import Path
 
-__version__ = "4.5.2"
+__version__ = "4.9.3"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules
 _api_instance = None
 _loaded_modules = {}
+_frozen_api = None  # Cached API module for frozen (PyInstaller) mode
+
+def _is_frozen():
+    """Check if running in a frozen PyInstaller bundle."""
+    return getattr(sys, 'frozen', False)
+
+def _get_frozen_api():
+    """Get the bundled API module when running frozen."""
+    global _frozen_api
+    if _frozen_api is None:
+        try:
+            import importlib.util
+            import importlib.machinery
+            ext = '.pyd' if sys.platform == 'win32' else '.so'
+
+            # Look for includecpp.dll in the same directory as the executable
+            exe_dir = Path(sys.executable).parent
+            dll_path = exe_dir / 'includecpp.dll'
+
+            if dll_path.exists():
+                # Use ExtensionFileLoader - module name must be 'api' to match PyInit_api
+                loader = importlib.machinery.ExtensionFileLoader('api', str(dll_path))
+                spec = importlib.util.spec_from_loader('api', loader, origin=str(dll_path))
+                if spec:
+                    api_module = importlib.util.module_from_spec(spec)
+                    sys.modules['api'] = api_module
+                    loader.exec_module(api_module)
+                    _frozen_api = api_module
+                    return _frozen_api
+
+            # Fallback: try api.pyd in _MEIPASS (legacy/bundled mode)
+            if hasattr(sys, '_MEIPASS'):
+                meipass = sys._MEIPASS
+                if meipass not in sys.path:
+                    sys.path.insert(0, meipass)
+
+                api_path = os.path.join(meipass, f'api{ext}')
+
+                if os.path.exists(api_path):
+                    loader = importlib.machinery.ExtensionFileLoader('api', api_path)
+                    spec = importlib.util.spec_from_loader('api', loader, origin=api_path)
+                    if spec:
+                        api_module = importlib.util.module_from_spec(spec)
+                        sys.modules['api'] = api_module
+                        loader.exec_module(api_module)
+                        _frozen_api = api_module
+                        return _frozen_api
+
+            # Fallback to regular import
+            import api
+            _frozen_api = api
+        except Exception as e:
+            # Store error for debugging
+            _frozen_api = False
+            print(f"[IncludeCPP] Failed to load frozen API: {e}", file=sys.stderr)
+    return _frozen_api if _frozen_api else None
 
 def _get_api():
-    """Get or create singleton CppApi instance."""
+    """Get or create singleton CppApi instance.
+
+    Checks INCLUDECPP_PROJECT env var for project path when running
+    from a different directory (e.g., via 'includecpp server run').
+    """
     global _api_instance
     if _api_instance is None:
-        _api_instance = CppApi()
+        # Check for project path from environment (set by 'server run -p')
+        project_path = os.environ.get('INCLUDECPP_PROJECT')
+        if project_path:
+            config_path = Path(project_path) / 'cpp.proj'
+            if config_path.exists():
+                _api_instance = CppApi(config_path=config_path)
+            else:
+                _api_instance = CppApi()
+        else:
+            _api_instance = CppApi()
     return _api_instance
 
 def __getattr__(name: str):
@@ -28,6 +100,20 @@ def __getattr__(name: str):
     if name in _loaded_modules:
         return _loaded_modules[name]
 
+    # In frozen mode (PyInstaller), try to get module from bundled api
+    if _is_frozen():
+        frozen_api = _get_frozen_api()
+        if frozen_api and hasattr(frozen_api, name):
+            module = getattr(frozen_api, name)
+            _loaded_modules[name] = module
+            return module
+        # If not found in frozen api, raise helpful error
+        raise AttributeError(
+            f"Module '{name}' not found in bundled executable. "
+            f"Ensure it was included during build with 'includecpp --make-exe'."
+        )
+
+    # Normal mode: use CppApi
     api = _get_api()
 
     if name not in api.registry:

includecpp/__init__.pyi

@@ -147,7 +147,8 @@ __version__: str
 # Dynamic module access via: from includecpp import <module_name>
 # Auto-generated module declarations
 # These allow: from includecpp import <module_name>
-cssl_core: Cssl_coreModuleWrapper
+cssl_runner: Cssl_runnerModuleWrapper
+mycpp: MycppModuleWrapper
 
 def __dir__() -> List[str]:
     """List available modules including dynamically loaded C++ modules."""