IncludeCPP 3.6.0__py3-none-any.whl → 3.7.1__py3-none-any.whl

includecpp/core/cssl/cssl_runtime.py

@@ -14,7 +14,8 @@ from .cssl_builtins import CSSLBuiltins
 from .cssl_modules import get_module_registry, get_standard_module
 from .cssl_types import (
     Parameter, DataStruct, Shuffled, Iterator, Combo,
-    Stack, Vector, Array, DataSpace, OpenQuote, List, Dictionary
+    Stack, Vector, Array, DataSpace, OpenQuote, List, Dictionary, Map,
+    CSSLClass, CSSLInstance
 )
 
 
@@ -145,6 +146,7 @@ class CSSLRuntime:
         self._injection_captures: Dict[str, Dict[str, Any]] = {}  # Captured %vars per injection
         self._current_captured_values: Dict[str, Any] = {}  # Current captured values during injection execution
         self._promoted_globals: Dict[str, Any] = {}  # NEW: Variables promoted via global()
+        self._current_instance: Optional[CSSLInstance] = None  # Current class instance for this-> access
         self._running = False
         self._exit_code = 0
         self._output_callback = output_callback  # Callback for console output (text, level)
@@ -386,6 +388,8 @@ class CSSLRuntime:
 
             if child.type == 'struct':
                 self._exec_struct(child)
+            elif child.type == 'class':
+                self._exec_class(child)
             elif child.type == 'function':
                 self._exec_function(child)
             elif child.type == 'global_assignment':
@@ -394,6 +398,9 @@ class CSSLRuntime:
             elif child.type == 'typed_declaration':
                 # Handle typed variable declaration: type<T> varName = value;
                 result = self._exec_typed_declaration(child)
+            elif child.type == 'instance_declaration':
+                # Handle instance declaration: instance<"name"> varName;
+                result = self._exec_instance_declaration(child)
             elif child.type in ('assignment', 'expression', 'inject', 'receive', 'flow',
                                'if', 'while', 'for', 'c_for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
@@ -661,6 +668,57 @@ class CSSLRuntime:
 
         return struct_data
 
+    def _exec_class(self, node: ASTNode) -> CSSLClass:
+        """Execute class definition - registers class in scope.
+
+        Parses class members and methods, creating a CSSLClass object
+        that can be instantiated with 'new'.
+        """
+        class_info = node.value
+        class_name = class_info.get('name')
+
+        members = {}  # Member variable defaults/types
+        methods = {}  # Method AST nodes
+        constructor = None
+
+        for child in node.children:
+            if child.type == 'function':
+                # This is a method
+                func_info = child.value
+                method_name = func_info.get('name')
+
+                if func_info.get('is_constructor') or method_name == class_name or method_name == '__init__':
+                    constructor = child
+                else:
+                    methods[method_name] = child
+
+            elif child.type == 'typed_declaration':
+                # This is a member variable
+                decl = child.value
+                member_name = decl.get('name')
+                member_type = decl.get('type')
+                member_value = decl.get('value')
+
+                # Store member info with type and optional default
+                members[member_name] = {
+                    'type': member_type,
+                    'default': self._evaluate(member_value) if member_value else None
+                }
+
+        # Create class definition object
+        class_def = CSSLClass(
+            name=class_name,
+            members=members,
+            methods=methods,
+            constructor=constructor
+        )
+
+        # Register class in scope
+        self.scope.set(class_name, class_def)
+        self.global_scope.set(class_name, class_def)
+
+        return class_def
+
     def _exec_function(self, node: ASTNode) -> Any:
         """Execute function definition - just registers it"""
         func_info = node.value
@@ -714,6 +772,8 @@ class CSSLRuntime:
             instance = List(element_type)
         elif type_name in ('dictionary', 'dict'):
             instance = Dictionary(element_type)
+        elif type_name == 'map':
+            instance = Map(element_type)
         else:
             # Default: evaluate the value or set to None
             instance = self._evaluate(value_node) if value_node else None
@@ -732,6 +792,34 @@ class CSSLRuntime:
         self.scope.set(var_name, instance)
         return instance
 
+    def _exec_instance_declaration(self, node: ASTNode) -> Any:
+        """Execute instance declaration: instance<"name"> varName;
+
+        Gets or creates a shared instance by name.
+        """
+        from ..cssl_bridge import _live_objects, SharedObjectProxy
+        decl = node.value
+        instance_name = decl.get('instance_name')
+        var_name = decl.get('name')
+        value_node = decl.get('value')
+
+        # Get existing shared instance
+        instance = None
+        if instance_name in _live_objects:
+            instance = SharedObjectProxy(instance_name, _live_objects[instance_name])
+        elif self.global_scope.has(f'${instance_name}'):
+            instance = self.global_scope.get(f'${instance_name}')
+
+        # If value is provided, use that and register as shared
+        if value_node:
+            instance = self._evaluate(value_node)
+            # Register in global scope for future access
+            self.global_scope.set(f'${instance_name}', instance)
+
+        # Store in scope
+        self.scope.set(var_name, instance)
+        return instance
+
     def _exec_global_assignment(self, node: ASTNode) -> Any:
         """Execute global variable assignment: global Name = value
 
@@ -1471,6 +1559,12 @@ class CSSLRuntime:
             name = target.value
             _live_objects[name] = final_value
             self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
+        elif target.type == 'instance_ref':
+            # value ==> instance<"name"> - create/update shared object
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = target.value
+            _live_objects[name] = final_value
+            self.global_scope.set(f'${name}', SharedObjectProxy(name, final_value))
         elif target.type == 'member_access':
             self._set_member(target, final_value)
 
@@ -1620,6 +1714,12 @@ class CSSLRuntime:
                 self._set_member(target, value)
             elif target.type == 'index_access':
                 self._set_index(target, value)
+            elif target.type == 'this_access':
+                # this->member = value
+                if self._current_instance is None:
+                    raise CSSLRuntimeError("'this' used outside of class method context")
+                member = target.value.get('member')
+                self._current_instance.set_member(member, value)
         elif isinstance(target, str):
             self.scope.set(target, value)
 
@@ -1767,6 +1867,28 @@ class CSSLRuntime:
                 return value
             raise CSSLRuntimeError(f"Captured reference '%{name}' not found.")
 
+        if node.type == 'instance_ref':
+            # instance<"name"> - get shared instance by name
+            # Works like $name but with explicit syntax
+            from ..cssl_bridge import _live_objects, SharedObjectProxy
+            name = node.value
+            if name in _live_objects:
+                return SharedObjectProxy(name, _live_objects[name])
+            # Check if stored in runtime's scope
+            scoped_val = self.global_scope.get(f'${name}')
+            if scoped_val is not None:
+                return scoped_val
+            # Return None if instance doesn't exist (can be created via ==>)
+            return None
+
+        if node.type == 'new':
+            # Create new instance of a class: new ClassName(args)
+            return self._eval_new(node)
+
+        if node.type == 'this_access':
+            # this->member access
+            return self._eval_this_access(node)
+
         if node.type == 'type_instantiation':
             # Create new instance of a type: stack<string>, vector<int>, etc.
             type_name = node.value.get('type')
@@ -2136,6 +2258,140 @@ class CSSLRuntime:
             hint="Typed functions use format: FunctionName<Type>(args)"
         )
 
+    def _eval_new(self, node: ASTNode) -> CSSLInstance:
+        """Evaluate 'new ClassName(args)' expression.
+
+        Creates a new instance of a CSSL class and calls its constructor.
+        """
+        class_name = node.value.get('class')
+        args = [self._evaluate(arg) for arg in node.value.get('args', [])]
+        kwargs = {k: self._evaluate(v) for k, v in node.value.get('kwargs', {}).items()}
+
+        # Get class definition from scope
+        class_def = self.scope.get(class_name)
+        if class_def is None:
+            class_def = self.global_scope.get(class_name)
+
+        if class_def is None:
+            raise CSSLRuntimeError(
+                f"Class '{class_name}' not found",
+                node.line,
+                hint="Make sure the class is defined before instantiation"
+            )
+
+        if not isinstance(class_def, CSSLClass):
+            raise CSSLRuntimeError(
+                f"'{class_name}' is not a class",
+                node.line,
+                hint=f"'{class_name}' is of type {type(class_def).__name__}"
+            )
+
+        # Create new instance
+        instance = CSSLInstance(class_def)
+
+        # Call constructor if defined
+        if class_def.constructor:
+            self._call_method(instance, class_def.constructor, args, kwargs)
+
+        return instance
+
+    def _eval_this_access(self, node: ASTNode) -> Any:
+        """Evaluate 'this->member' access.
+
+        Returns the value of a member from the current class instance.
+        """
+        if self._current_instance is None:
+            raise CSSLRuntimeError(
+                "'this' used outside of class method context",
+                node.line if hasattr(node, 'line') else 0,
+                hint="'this->' can only be used inside class methods"
+            )
+
+        member = node.value.get('member')
+
+        # Check if it's a chained access (this->a->b)
+        if 'object' in node.value:
+            # First evaluate the object part
+            obj = self._evaluate(node.value.get('object'))
+            if obj is None:
+                return None
+            if hasattr(obj, member):
+                return getattr(obj, member)
+            if isinstance(obj, dict):
+                return obj.get(member)
+            return None
+
+        # Direct this->member access
+        instance = self._current_instance
+
+        # Check if it's a member variable
+        if instance.has_member(member):
+            return instance.get_member(member)
+
+        # Check if it's a method
+        if instance.has_method(member):
+            # Return a callable that will invoke the method with instance context
+            method_node = instance.get_method(member)
+            return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
+
+        raise CSSLRuntimeError(
+            f"'{instance._class.name}' has no member or method '{member}'",
+            node.line if hasattr(node, 'line') else 0
+        )
+
+    def _call_method(self, instance: CSSLInstance, method_node: ASTNode, args: list, kwargs: dict = None) -> Any:
+        """Call a method on an instance with 'this' context.
+
+        Sets up the instance as the current 'this' context and executes the method.
+        """
+        kwargs = kwargs or {}
+        func_info = method_node.value
+        params = func_info.get('params', [])
+        modifiers = func_info.get('modifiers', [])
+
+        # Check for undefined modifier
+        is_undefined = 'undefined' in modifiers
+
+        # Create new scope for method
+        new_scope = Scope(parent=self.scope)
+
+        # Bind parameters
+        for i, param in enumerate(params):
+            param_name = param['name'] if isinstance(param, dict) else param
+
+            if param_name in kwargs:
+                new_scope.set(param_name, kwargs[param_name])
+            elif i < len(args):
+                new_scope.set(param_name, args[i])
+            else:
+                new_scope.set(param_name, None)
+
+        # Save current state
+        old_scope = self.scope
+        old_instance = self._current_instance
+
+        # Set up method context
+        self.scope = new_scope
+        self._current_instance = instance
+
+        try:
+            for child in method_node.children:
+                if not self._running:
+                    break
+                self._execute_node(child)
+        except CSSLReturn as ret:
+            return ret.value
+        except Exception as e:
+            if is_undefined:
+                return None
+            raise
+        finally:
+            # Restore previous state
+            self.scope = old_scope
+            self._current_instance = old_instance
+
+        return None
+
     def _eval_member_access(self, node: ASTNode) -> Any:
         """Evaluate member access"""
         obj = self._evaluate(node.value.get('object'))
@@ -2149,6 +2405,17 @@ class CSSLRuntime:
         if isinstance(obj, Parameter) and member == 'return':
             member = 'return_'
 
+        # === CSSL CLASS INSTANCE METHODS ===
+        if isinstance(obj, CSSLInstance):
+            # Check for member variable
+            if obj.has_member(member):
+                return obj.get_member(member)
+            # Check for method
+            if obj.has_method(member):
+                method_node = obj.get_method(member)
+                return lambda *args, **kwargs: self._call_method(obj, method_node, list(args), kwargs)
+            raise CSSLRuntimeError(f"'{obj._class.name}' has no member or method '{member}'")
+
         # === STRING METHODS ===
         if isinstance(obj, str):
             string_methods = self._get_string_method(obj, member)
@@ -2382,6 +2649,11 @@ class CSSLRuntime:
         if obj is None:
             return
 
+        # Check for CSSLInstance - use set_member method
+        if isinstance(obj, CSSLInstance):
+            obj.set_member(member, value)
+            return
+
         # Check for SharedObjectProxy - directly access underlying object
         # This is more robust than relying on the proxy's __setattr__
         if hasattr(obj, '_direct_object') and hasattr(obj, '_name'):

includecpp/core/cssl/cssl_types.py

@@ -1281,10 +1281,232 @@ def create_dictionary(key_type: str = 'dynamic', value_type: str = 'dynamic') ->
     return Dictionary(key_type, value_type)
 
 
+class Map(dict):
+    """C++ style map container with ordered key-value pairs.
+
+    Similar to Dictionary but with C++ map semantics.
+    Keys are maintained in sorted order.
+
+    Usage:
+        map<string, int> ages;
+        ages.insert("Alice", 30);
+        ages.find("Alice");
+        ages.erase("Alice");
+    """
+
+    def __init__(self, key_type: str = 'dynamic', value_type: str = 'dynamic'):
+        super().__init__()
+        self._key_type = key_type
+        self._value_type = value_type
+
+    def insert(self, key: Any, value: Any) -> 'Map':
+        """Insert key-value pair (C++ style)"""
+        self[key] = value
+        return self
+
+    def find(self, key: Any) -> Optional[Any]:
+        """Find value by key, returns None if not found (C++ style)"""
+        return self.get(key, None)
+
+    def erase(self, key: Any) -> bool:
+        """Erase key-value pair, returns True if existed"""
+        if key in self:
+            del self[key]
+            return True
+        return False
+
+    def contains(self, key: Any) -> bool:
+        """Check if key exists (C++20 style)"""
+        return key in self
+
+    def count(self, key: Any) -> int:
+        """Return 1 if key exists, 0 otherwise (C++ style)"""
+        return 1 if key in self else 0
+
+    def size(self) -> int:
+        """Return map size"""
+        return len(self)
+
+    def empty(self) -> bool:
+        """Check if map is empty"""
+        return len(self) == 0
+
+    def at(self, key: Any) -> Any:
+        """Get value at key, raises error if not found (C++ style)"""
+        if key not in self:
+            raise KeyError(f"Key '{key}' not found in map")
+        return self[key]
+
+    def begin(self) -> Optional[tuple]:
+        """Return first key-value pair"""
+        if len(self) == 0:
+            return None
+        first_key = next(iter(self))
+        return (first_key, self[first_key])
+
+    def end(self) -> Optional[tuple]:
+        """Return last key-value pair"""
+        if len(self) == 0:
+            return None
+        last_key = list(self.keys())[-1]
+        return (last_key, self[last_key])
+
+    def lower_bound(self, key: Any) -> Optional[Any]:
+        """Find first key >= given key (for sorted keys)"""
+        sorted_keys = sorted(self.keys())
+        for k in sorted_keys:
+            if k >= key:
+                return k
+        return None
+
+    def upper_bound(self, key: Any) -> Optional[Any]:
+        """Find first key > given key (for sorted keys)"""
+        sorted_keys = sorted(self.keys())
+        for k in sorted_keys:
+            if k > key:
+                return k
+        return None
+
+
+def create_map(key_type: str = 'dynamic', value_type: str = 'dynamic') -> Map:
+    """Create a Map object"""
+    return Map(key_type, value_type)
+
+
+class CSSLClass:
+    """Represents a CSSL class definition.
+
+    Stores class name, member variables, methods, and constructor.
+    Used by the runtime to instantiate CSSLInstance objects.
+    """
+
+    def __init__(self, name: str, members: Dict[str, Any] = None,
+                 methods: Dict[str, Any] = None, constructor: Any = None):
+        self.name = name
+        self.members = members or {}  # Default member values/types
+        self.methods = methods or {}  # Method AST nodes
+        self.constructor = constructor  # Constructor AST node
+
+    def __repr__(self):
+        return f"<CSSLClass '{self.name}' with {len(self.methods)} methods>"
+
+
+class CSSLInstance:
+    """Represents an instance of a CSSL class.
+
+    Holds instance member values and provides access to class methods.
+    Supports this-> member access pattern.
+    """
+
+    def __init__(self, class_def: CSSLClass):
+        self._class = class_def
+        self._members: Dict[str, Any] = {}
+        # Initialize members with defaults from class definition
+        for name, default in class_def.members.items():
+            if isinstance(default, dict):
+                # Type declaration with optional default
+                member_type = default.get('type')
+                member_default = default.get('default')
+
+                if member_default is not None:
+                    self._members[name] = member_default
+                elif member_type:
+                    # Create instance of container types
+                    self._members[name] = self._create_default_for_type(member_type)
+                else:
+                    self._members[name] = None
+            else:
+                self._members[name] = default
+
+    def _create_default_for_type(self, type_name: str) -> Any:
+        """Create a default value for a given type name."""
+        # Container types
+        if type_name == 'map':
+            return Map()
+        elif type_name in ('stack',):
+            return Stack()
+        elif type_name in ('vector',):
+            return Vector()
+        elif type_name in ('array',):
+            return Array()
+        elif type_name in ('list',):
+            return List()
+        elif type_name in ('dictionary', 'dict'):
+            return Dictionary()
+        elif type_name == 'datastruct':
+            return DataStruct()
+        elif type_name == 'dataspace':
+            return DataSpace()
+        elif type_name == 'shuffled':
+            return Shuffled()
+        elif type_name == 'iterator':
+            return Iterator()
+        elif type_name == 'combo':
+            return Combo()
+        # Primitive types
+        elif type_name == 'int':
+            return 0
+        elif type_name == 'float':
+            return 0.0
+        elif type_name == 'string':
+            return ""
+        elif type_name == 'bool':
+            return False
+        elif type_name == 'json':
+            return {}
+        return None
+
+    def get_member(self, name: str) -> Any:
+        """Get member value by name"""
+        if name in self._members:
+            return self._members[name]
+        raise AttributeError(f"'{self._class.name}' has no member '{name}'")
+
+    def set_member(self, name: str, value: Any) -> None:
+        """Set member value by name"""
+        self._members[name] = value
+
+    def has_member(self, name: str) -> bool:
+        """Check if member exists"""
+        return name in self._members
+
+    def get_method(self, name: str) -> Any:
+        """Get method AST node by name"""
+        if name in self._class.methods:
+            return self._class.methods[name]
+        raise AttributeError(f"'{self._class.name}' has no method '{name}'")
+
+    def has_method(self, name: str) -> bool:
+        """Check if method exists"""
+        return name in self._class.methods
+
+    def __getattr__(self, name: str) -> Any:
+        """Allow direct attribute access for members"""
+        if name.startswith('_'):
+            raise AttributeError(name)
+        if name in self._members:
+            return self._members[name]
+        raise AttributeError(f"'{self._class.name}' has no member '{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):
+        return f"<CSSLInstance of '{self._class.name}'>"
+
+
 __all__ = [
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array', 'List', 'Dictionary',
+    'OpenFind', 'Parameter', 'Stack', 'Vector', 'Array', 'List', 'Dictionary', 'Map',
+    'CSSLClass', 'CSSLInstance',
     '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_stack', 'create_vector', 'create_array', 'create_list', 'create_dictionary', 'create_map'
 ]

includecpp/vscode/cssl/package.json

@@ -1,14 +1,24 @@
 {
     "name": "cssl",
     "displayName": "CSSL - CSO Service Script Language",
-    "description": "Syntax highlighting and language support for CSSL scripts",
-    "version": "1.0.0",
+    "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
+    "version": "1.1.0",
     "publisher": "IncludeCPP",
+    "icon": "images/cssl-icon.png",
     "engines": {
         "vscode": "^1.60.0"
     },
     "categories": [
-        "Programming Languages"
+        "Programming Languages",
+        "Snippets"
+    ],
+    "keywords": [
+        "cssl",
+        "cso",
+        "script",
+        "includecpp",
+        "c++",
+        "python"
     ],
     "contributes": {
         "languages": [
@@ -16,7 +26,11 @@
                 "id": "cssl",
                 "aliases": ["CSSL", "cssl", "CSO Service Script"],
                 "extensions": [".cssl", ".cssl-pl", ".cssl-mod"],
-                "configuration": "./language-configuration.json"
+                "configuration": "./language-configuration.json",
+                "icon": {
+                    "light": "./images/cssl-icon.png",
+                    "dark": "./images/cssl-icon.png"
+                }
             }
         ],
         "grammars": [
@@ -25,6 +39,12 @@
                 "scopeName": "source.cssl",
                 "path": "./syntaxes/cssl.tmLanguage.json"
             }
+        ],
+        "snippets": [
+            {
+                "language": "cssl",
+                "path": "./snippets/cssl.snippets.json"
+            }
         ]
     }
 }