IncludeCPP 4.0.2__py3-none-any.whl → 4.3.0__py3-none-any.whl

includecpp/core/cssl/cssl_syntax.py

@@ -31,6 +31,11 @@ class TokenCategory(Enum):
     NULL = auto()             # null, None
     PACKAGE_KW = auto()       # package, package-includes - NEW
     TYPE_LITERAL = auto()     # list, dict - NEW
+    # v4.1.0: Multi-language support
+    SUPPORTS_KW = auto()      # supports keyword (magenta)
+    LIBINCLUDE_KW = auto()    # libinclude (yellow/gold)
+    LANG_PREFIX = auto()      # Language prefix before $ (cyan): cpp$, py$, java$
+    LANG_INSTANCE = auto()    # Instance name after $ (orange): cpp$ClassName
 
 
 @dataclass
@@ -52,9 +57,17 @@ KEYWORDS = {
     'start', 'stop', 'wait_for', 'on_event', 'emit_event',
     'await',
     # NEW: Extended keywords
-    'package', 'package-includes', 'exec', 'as', 'global'
+    'package', 'package-includes', 'exec', 'as', 'global',
+    # v4.1.0: Multi-language support (handled separately for special colors)
+    # 'supports', 'libinclude' - see MULTI_LANG_KEYWORDS
 }
 
+# v4.1.0: Multi-language keywords with special highlighting
+MULTI_LANG_KEYWORDS = {'supports', 'libinclude'}
+
+# v4.1.0: Language identifiers for cross-language instance access
+LANGUAGE_IDS = {'cpp', 'py', 'python', 'java', 'csharp', 'js', 'javascript'}
+
 # NEW: Package-related keywords for special highlighting
 PACKAGE_KEYWORDS = {'package', 'package-includes'}
 
@@ -145,6 +158,33 @@ class CSSLSyntaxRules:
             category=TokenCategory.TYPE_LITERAL
         ))
 
+        # v4.1.0: Multi-language support keywords
+        # 'supports' keyword (magenta) - must be before regular keywords
+        rules.append(HighlightRule(
+            pattern=r'\bsupports\b',
+            category=TokenCategory.SUPPORTS_KW
+        ))
+
+        # 'libinclude' keyword (yellow/gold)
+        rules.append(HighlightRule(
+            pattern=r'\blibinclude\b',
+            category=TokenCategory.LIBINCLUDE_KW
+        ))
+
+        # v4.1.0: Language$Instance patterns (cpp$ClassName, py$Object)
+        # Match language prefix before $ (cyan)
+        rules.append(HighlightRule(
+            pattern=r'\b(cpp|py|python|java|csharp|js|javascript)\$',
+            category=TokenCategory.LANG_PREFIX,
+            group=1
+        ))
+        # Match instance name after $ (orange)
+        rules.append(HighlightRule(
+            pattern=r'\b(?:cpp|py|python|java|csharp|js|javascript)\$([A-Za-z_][A-Za-z0-9_]*)',
+            category=TokenCategory.LANG_INSTANCE,
+            group=1
+        ))
+
         # Self-references (s@Name, s@Backend.Loop)
         rules.append(HighlightRule(
             pattern=r's@[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*',
@@ -233,6 +273,11 @@ class ColorScheme:
         TokenCategory.NULL: '#ff6464',         # Red
         TokenCategory.PACKAGE_KW: '#bd93f9',   # Purple for package - NEW
         TokenCategory.TYPE_LITERAL: '#8be9fd', # Cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '#ff79c6',  # Magenta/Pink for 'supports'
+        TokenCategory.LIBINCLUDE_KW: '#f1fa8c',# Yellow/Gold for 'libinclude'
+        TokenCategory.LANG_PREFIX: '#8be9fd',  # Cyan for language prefix (cpp$)
+        TokenCategory.LANG_INSTANCE: '#ffb86c',# Orange for instance name ($ClassName)
     }
 
     # Light theme variant
@@ -252,6 +297,11 @@ class ColorScheme:
         TokenCategory.NULL: '#ff0000',         # Red
         TokenCategory.PACKAGE_KW: '#8b008b',   # DarkMagenta for package - NEW
         TokenCategory.TYPE_LITERAL: '#008b8b', # Dark cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '#d63384',  # Dark Magenta for 'supports'
+        TokenCategory.LIBINCLUDE_KW: '#b8860b',# DarkGoldenrod for 'libinclude'
+        TokenCategory.LANG_PREFIX: '#0d6efd',  # Blue for language prefix (cpp$)
+        TokenCategory.LANG_INSTANCE: '#fd7e14',# Orange for instance name ($ClassName)
     }
 
 
@@ -334,6 +384,11 @@ def highlight_cssl_ansi(source: str) -> str:
         TokenCategory.NULL: '\033[91m',         # Red
         TokenCategory.PACKAGE_KW: '\033[95m',   # Magenta for package - NEW
         TokenCategory.TYPE_LITERAL: '\033[96m', # Cyan for type literals - NEW
+        # v4.1.0: Multi-language support colors
+        TokenCategory.SUPPORTS_KW: '\033[95m',  # Magenta for 'supports'
+        TokenCategory.LIBINCLUDE_KW: '\033[93m',# Yellow for 'libinclude'
+        TokenCategory.LANG_PREFIX: '\033[96m',  # Cyan for language prefix (cpp$)
+        TokenCategory.LANG_INSTANCE: '\033[33m',# Orange/Yellow for instance name
     }
     RESET = '\033[0m'
 
@@ -439,6 +494,10 @@ def export_textmate_grammar() -> dict:
                 "name": "comment.line.cssl",
                 "match": "#.*$"
             },
+            {
+                "name": "comment.line.double-slash.cssl",
+                "match": "//.*$"
+            },
             {
                 "name": "string.quoted.double.cssl",
                 "match": '"(?:[^"\\\\]|\\\\.)*"'
@@ -447,6 +506,23 @@ def export_textmate_grammar() -> dict:
                 "name": "string.quoted.single.cssl",
                 "match": "'(?:[^'\\\\]|\\\\.)*'"
             },
+            # v4.1.0: Multi-language support
+            {
+                "name": "keyword.control.supports.cssl",
+                "match": "\\bsupports\\b"
+            },
+            {
+                "name": "support.function.libinclude.cssl",
+                "match": "\\blibinclude\\b"
+            },
+            {
+                "name": "variable.language.lang-instance.cssl",
+                "match": "\\b(cpp|py|python|java|csharp|js|javascript)\\$([A-Za-z_][A-Za-z0-9_]*)",
+                "captures": {
+                    "1": {"name": "entity.name.type.language.cssl"},
+                    "2": {"name": "variable.other.instance.cssl"}
+                }
+            },
             {
                 "name": "variable.other.self-reference.cssl",
                 "match": "s@[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*"
@@ -455,9 +531,13 @@ def export_textmate_grammar() -> dict:
                 "name": "variable.other.module-reference.cssl",
                 "match": "@[A-Za-z_][A-Za-z0-9_]*(?:\\.[A-Za-z_][A-Za-z0-9_]*)*"
             },
+            {
+                "name": "keyword.other.package.cssl",
+                "match": "\\b(package|package-includes)\\b"
+            },
             {
                 "name": "keyword.control.cssl",
-                "match": "\\b(service-init|service-run|service-include|struct|define|if|else|elif|while|for|foreach|in|switch|case|default|break|continue|return|try|catch|await)\\b"
+                "match": "\\b(service-init|service-run|service-include|struct|define|class|constr|if|else|elif|while|for|foreach|in|switch|case|default|break|continue|return|try|catch|finally|throw|await|extends|overwrites|global|as|exec)\\b"
             },
             {
                 "name": "keyword.operator.cssl",
@@ -465,7 +545,7 @@ def export_textmate_grammar() -> dict:
             },
             {
                 "name": "constant.language.cssl",
-                "match": "\\b(True|False|true|false|null|None)\\b"
+                "match": "\\b(True|False|true|false|null|None|none)\\b"
             },
             {
                 "name": "constant.numeric.cssl",
@@ -473,7 +553,11 @@ def export_textmate_grammar() -> dict:
             },
             {
                 "name": "keyword.operator.assignment.cssl",
-                "match": "<==|==>|->|<-"
+                "match": "<==|==>|->|<-|::"
+            },
+            {
+                "name": "support.type.cssl",
+                "match": "\\b(list|dict)\\b(?!\\s*\\()"
             }
         ]
     }

includecpp/core/cssl/cssl_types.py

@@ -1443,6 +1443,195 @@ def create_map(key_type: str = 'dynamic', value_type: str = 'dynamic') -> Map:
     return Map(key_type, value_type)
 
 
+class ByteArrayed:
+    """Function-to-byte mapping with pattern matching (v4.2.5).
+
+    Maps function references to byte positions and executes pattern matching
+    based on function return values.
+
+    Usage:
+        bytearrayed MyBytes {
+            &func1;              // Position 0x0
+            &func2;              // Position 0x1
+            case {0, 1} {        // Match when func1=0, func2=1
+                printl("Match!");
+            }
+            default {
+                printl("No match");
+            }
+        }
+
+        MyBytes();           // Execute pattern matching
+        x = MyBytes["0x0"];  // Get value at position 0
+        x = MyBytes[0];      // Get value at position 0
+    """
+
+    def __init__(self, name: str, func_refs: List[Dict], cases: List[Dict],
+                 default_block: Any = None, runtime: Any = None):
+        self.name = name
+        self.func_refs = func_refs  # [{position, hex_pos, func_ref}, ...]
+        self.cases = cases          # [{pattern, body}, ...]
+        self.default_block = default_block
+        self._runtime = runtime
+        self._cached_values: Dict[int, Any] = {}  # Cached return values
+
+    def __call__(self, *args, **kwargs) -> Any:
+        """Execute pattern matching - probe functions and match cases.
+
+        Functions are executed "invisibly" (side-effect free where possible)
+        to get their current return values, then patterns are matched.
+        """
+        # Get current return values from all referenced functions
+        values = self._probe_functions()
+
+        # Try to match each case pattern
+        for case in self.cases:
+            pattern = case['pattern']
+            body = case['body']
+            if self._match_pattern(pattern, values):
+                return self._execute_body(body)
+
+        # No case matched - execute default if present
+        if self.default_block:
+            return self._execute_body(self.default_block)
+
+        return None
+
+    def _probe_functions(self) -> List[Any]:
+        """Execute referenced functions invisibly to get their return values."""
+        values = []
+        for ref in self.func_refs:
+            func_name = ref['func_ref']
+            position = ref['position']
+
+            # Look up the function in runtime scope
+            func = None
+            if self._runtime:
+                func = self._runtime.scope.get(func_name)
+                if func is None:
+                    func = self._runtime.global_scope.get(func_name)
+                if func is None:
+                    func = self._runtime.builtins.get_function(func_name)
+
+            # Execute the function to get its return value
+            if func is not None:
+                try:
+                    if callable(func):
+                        result = func()
+                    elif hasattr(func, 'type') and func.type == 'function':
+                        # CSSL function node
+                        result = self._runtime._call_function(func, [])
+                    else:
+                        result = func
+                except Exception:
+                    result = None
+            else:
+                result = None
+
+            values.append(result)
+            self._cached_values[position] = result
+
+        return values
+
+    def _match_pattern(self, pattern: List[Dict], values: List[Any]) -> bool:
+        """Check if pattern matches the current values."""
+        for i, p in enumerate(pattern):
+            if i >= len(values):
+                return False
+
+            p_type = p.get('type')
+            value = values[i]
+
+            if p_type == 'wildcard':
+                # _ matches anything
+                continue
+            elif p_type == 'value':
+                # Exact value match
+                if value != p.get('value'):
+                    return False
+            elif p_type == 'indexed':
+                # Match at specific index
+                idx = p.get('index')
+                if isinstance(idx, str) and idx.startswith('0x'):
+                    idx = int(idx, 16)
+                if idx < len(values):
+                    if values[idx] != self._runtime._evaluate(p.get('value')) if hasattr(p.get('value'), 'type') else p.get('value'):
+                        return False
+            elif p_type == 'type_match':
+                # Match by type
+                type_name = p.get('type_name')
+                if not self._check_type(value, type_name):
+                    return False
+            elif p_type == 'variable':
+                # Match against variable value
+                var_name = p.get('name')
+                var_value = self._runtime.scope.get(var_name)
+                if var_value is None:
+                    var_value = self._runtime.global_scope.get(var_name)
+                if value != var_value:
+                    return False
+
+        return True
+
+    def _check_type(self, value: Any, type_name: str) -> bool:
+        """Check if value matches the specified type."""
+        type_checks = {
+            'int': lambda v: isinstance(v, int) and not isinstance(v, bool),
+            'float': lambda v: isinstance(v, float),
+            'string': lambda v: isinstance(v, str),
+            'bool': lambda v: isinstance(v, bool),
+            'list': lambda v: isinstance(v, list),
+            'dict': lambda v: isinstance(v, dict),
+            'dynamic': lambda v: True,
+        }
+        if type_name in type_checks:
+            return type_checks[type_name](value)
+        # Check for generic types like vector<string>
+        if '<' in type_name:
+            base = type_name.split('<')[0]
+            return isinstance(value, (list, tuple, set))
+        return True
+
+    def _execute_body(self, body: List) -> Any:
+        """Execute a case body block."""
+        if not self._runtime:
+            return None
+        result = None
+        for node in body:
+            result = self._runtime._execute_node(node)
+        return result
+
+    def __getitem__(self, key: Union[int, str]) -> Any:
+        """Access byte value by index or hex position.
+
+        MyBytes[0]      - Get value at position 0
+        MyBytes["0x0"]  - Get value at position 0
+        """
+        if isinstance(key, str):
+            if key.startswith('0x') or key.startswith('0X'):
+                key = int(key, 16)
+            elif key.isdigit():
+                key = int(key)
+            else:
+                raise KeyError(f"Invalid bytearrayed key: {key}")
+
+        if key in self._cached_values:
+            return self._cached_values[key]
+
+        # Probe functions to get values if not cached
+        if not self._cached_values:
+            self._probe_functions()
+
+        return self._cached_values.get(key)
+
+    def __len__(self) -> int:
+        """Return number of byte positions."""
+        return len(self.func_refs)
+
+    def __repr__(self) -> str:
+        return f"ByteArrayed({self.name}, positions={len(self.func_refs)})"
+
+
 class CSSLClass:
     """Represents a CSSL class definition.
 
@@ -1624,10 +1813,181 @@ class CSSLInstance:
         return f"<{self._class.name} instance at 0x{id(self):x}>"
 
 
+class UniversalInstance:
+    """Universal shared container accessible from CSSL, Python, and C++.
+
+    Created via instance<"name"> syntax in CSSL or getInstance("name") in Python.
+    Supports dynamic member/method injection via +<<== operator.
+
+    Example CSSL:
+        instance<"myContainer"> container;
+        container +<<== { void sayHello() { printl("Hello!"); } }
+        container.sayHello();
+
+    Example Python:
+        container = cssl.getInstance("myContainer")
+        container.sayHello()
+    """
+
+    # Global registry for all universal instances
+    _registry: Dict[str, 'UniversalInstance'] = {}
+
+    def __init__(self, name: str):
+        self._name = name
+        self._members: Dict[str, Any] = {}
+        self._methods: Dict[str, Any] = {}  # Method name -> AST node or callable
+        self._injections: List[Any] = []  # Code blocks injected via +<<==
+        self._runtime = None  # Weak reference to CSSL runtime for method calls
+        # Register globally
+        UniversalInstance._registry[name] = self
+
+    @classmethod
+    def get_or_create(cls, name: str) -> 'UniversalInstance':
+        """Get existing instance or create new one."""
+        if name in cls._registry:
+            return cls._registry[name]
+        return cls(name)
+
+    @classmethod
+    def get(cls, name: str) -> Optional['UniversalInstance']:
+        """Get existing instance by name, returns None if not found."""
+        return cls._registry.get(name)
+
+    @classmethod
+    def exists(cls, name: str) -> bool:
+        """Check if instance exists."""
+        return name in cls._registry
+
+    @classmethod
+    def delete(cls, name: str) -> bool:
+        """Delete instance from registry."""
+        if name in cls._registry:
+            del cls._registry[name]
+            return True
+        return False
+
+    @classmethod
+    def clear_all(cls) -> int:
+        """Clear all instances. Returns count of cleared instances."""
+        count = len(cls._registry)
+        cls._registry.clear()
+        return count
+
+    @classmethod
+    def list_all(cls) -> List[str]:
+        """List all instance names."""
+        return list(cls._registry.keys())
+
+    @property
+    def name(self) -> str:
+        """Get instance name."""
+        return self._name
+
+    def set_member(self, name: str, value: Any) -> None:
+        """Set a member value."""
+        self._members[name] = value
+
+    def get_member(self, name: str) -> Any:
+        """Get a member value."""
+        if name in self._members:
+            return self._members[name]
+        raise AttributeError(f"Instance '{self._name}' has no member '{name}'")
+
+    def has_member(self, name: str) -> bool:
+        """Check if member exists."""
+        return name in self._members
+
+    def set_runtime(self, runtime: Any) -> None:
+        """Set the runtime reference for method calls from Python."""
+        import weakref
+        self._runtime = weakref.ref(runtime)
+
+    def set_method(self, name: str, method: Any, runtime: Any = None) -> None:
+        """Set a method (AST node or callable)."""
+        self._methods[name] = method
+        if runtime is not None and self._runtime is None:
+            self.set_runtime(runtime)
+
+    def get_method(self, name: str) -> Any:
+        """Get a method by name."""
+        if name in self._methods:
+            return self._methods[name]
+        raise AttributeError(f"Instance '{self._name}' has no method '{name}'")
+
+    def has_method(self, name: str) -> bool:
+        """Check if method exists."""
+        return name in self._methods
+
+    def add_injection(self, code_block: Any) -> None:
+        """Add a code injection (from +<<== operator)."""
+        self._injections.append(code_block)
+
+    def get_injections(self) -> List[Any]:
+        """Get all injected code blocks."""
+        return self._injections
+
+    def get_all_members(self) -> Dict[str, Any]:
+        """Get all members."""
+        return dict(self._members)
+
+    def get_all_methods(self) -> Dict[str, Any]:
+        """Get all methods."""
+        return dict(self._methods)
+
+    def __getattr__(self, name: str) -> Any:
+        """Allow direct attribute access for members and methods."""
+        if name.startswith('_'):
+            raise AttributeError(name)
+        if name in object.__getattribute__(self, '_members'):
+            return object.__getattribute__(self, '_members')[name]
+        if name in object.__getattribute__(self, '_methods'):
+            method = object.__getattribute__(self, '_methods')[name]
+            runtime_ref = object.__getattribute__(self, '_runtime')
+
+            # If method is an AST node and we have a runtime, create a callable wrapper
+            if hasattr(method, 'type') and method.type == 'function' and runtime_ref is not None:
+                runtime = runtime_ref()  # Dereference weakref
+                if runtime is not None:
+                    instance = self
+                    def method_caller(*args, **kwargs):
+                        # Set 'this' context and call the method
+                        old_this = runtime.scope.get('this')
+                        runtime.scope.set('this', instance)
+                        try:
+                            return runtime._call_function(method, list(args))
+                        finally:
+                            if old_this is not None:
+                                runtime.scope.set('this', old_this)
+                            elif hasattr(runtime.scope, 'remove'):
+                                runtime.scope.remove('this')
+                    return method_caller
+            # Return method directly if already callable or no runtime
+            return method
+        raise AttributeError(f"Instance '{object.__getattribute__(self, '_name')}' has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Allow direct attribute setting for members."""
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            if hasattr(self, '_members'):
+                self._members[name] = value
+            else:
+                object.__setattr__(self, name, value)
+
+    def __repr__(self):
+        members = len(self._members)
+        methods = len(self._methods)
+        return f"<UniversalInstance '{self._name}' ({members} members, {methods} methods)>"
+
+    def __str__(self):
+        return f"<UniversalInstance '{self._name}'>"
+
+
 __all__ = [
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
     'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array', 'List', 'Dictionary', 'Map',
-    'CSSLClass', 'CSSLInstance',
+    'CSSLClass', 'CSSLInstance', 'UniversalInstance',
     'create_datastruct', 'create_shuffled', 'create_iterator',
     'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter',
     'create_stack', 'create_vector', 'create_array', 'create_list', 'create_dictionary', 'create_map'