IncludeCPP 3.7.25__py3-none-any.whl → 3.8.8__py3-none-any.whl

includecpp/core/cssl/cssl_types.py

@@ -1448,17 +1448,62 @@ class CSSLClass:
 
     Stores class name, member variables, methods, and constructor.
     Used by the runtime to instantiate CSSLInstance objects.
+    Supports inheritance via the 'parent' attribute.
     """
 
     def __init__(self, name: str, members: Dict[str, Any] = None,
-                 methods: Dict[str, Any] = None, constructor: Any = None):
+                 methods: Dict[str, Any] = None, constructor: Any = None,
+                 parent: 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
+        self.parent = parent  # Parent class (CSSLClass or CSSLizedPythonObject)
+
+    def get_all_members(self) -> Dict[str, Any]:
+        """Get all members including inherited ones."""
+        all_members = {}
+        # First add parent members (can be overridden)
+        if self.parent:
+            if hasattr(self.parent, 'get_all_members'):
+                all_members.update(self.parent.get_all_members())
+            elif hasattr(self.parent, 'members'):
+                all_members.update(self.parent.members)
+            elif hasattr(self.parent, '_python_obj'):
+                # CSSLizedPythonObject - get attributes from Python object
+                py_obj = self.parent._python_obj
+                if hasattr(py_obj, '__dict__'):
+                    for key, val in py_obj.__dict__.items():
+                        if not key.startswith('_'):
+                            all_members[key] = {'type': 'dynamic', 'default': val}
+        # Then add own members (override parent)
+        all_members.update(self.members)
+        return all_members
+
+    def get_all_methods(self) -> Dict[str, Any]:
+        """Get all methods including inherited ones."""
+        all_methods = {}
+        # First add parent methods (can be overridden)
+        if self.parent:
+            if hasattr(self.parent, 'get_all_methods'):
+                all_methods.update(self.parent.get_all_methods())
+            elif hasattr(self.parent, 'methods'):
+                all_methods.update(self.parent.methods)
+            elif hasattr(self.parent, '_python_obj'):
+                # CSSLizedPythonObject - get methods from Python object
+                py_obj = self.parent._python_obj
+                for name in dir(py_obj):
+                    if not name.startswith('_'):
+                        attr = getattr(py_obj, name, None)
+                        if callable(attr):
+                            all_methods[name] = ('python_method', attr)
+        # Then add own methods (override parent)
+        all_methods.update(self.methods)
+        return all_methods
 
     def __repr__(self):
-        return f"<CSSLClass '{self.name}' with {len(self.methods)} methods>"
+        parent_info = f" extends {self.parent.name}" if self.parent and hasattr(self.parent, 'name') else ""
+        return f"<CSSLClass '{self.name}'{parent_info} with {len(self.methods)} methods>"
 
 
 class CSSLInstance:
@@ -1471,8 +1516,9 @@ class CSSLInstance:
     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():
+        # Initialize members with defaults from class definition (including inherited)
+        all_members = class_def.get_all_members() if hasattr(class_def, 'get_all_members') else class_def.members
+        for name, default in all_members.items():
             if isinstance(default, dict):
                 # Type declaration with optional default
                 member_type = default.get('type')
@@ -1541,14 +1587,17 @@ class CSSLInstance:
         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]
+        """Get method AST node by name (including inherited methods)"""
+        # Use get_all_methods to include inherited methods
+        all_methods = self._class.get_all_methods() if hasattr(self._class, 'get_all_methods') else self._class.methods
+        if name in all_methods:
+            return all_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
+        """Check if method exists (including inherited methods)"""
+        all_methods = self._class.get_all_methods() if hasattr(self._class, 'get_all_methods') else self._class.methods
+        return name in all_methods
 
     def __getattr__(self, name: str) -> Any:
         """Allow direct attribute access for members"""

includecpp/vscode/cssl/extension.js

@@ -53,23 +53,23 @@ function activate(context) {
         // Run the CSSL file using includecpp cssl run
         const args = ['-m', 'includecpp', 'cssl', 'run', filePath];
 
-        const process = spawn(pythonPath, args, {
+        const childProcess = spawn(pythonPath, args, {
             cwd: path.dirname(filePath),
             env: { ...process.env }
         });
 
         let hasError = false;
 
-        process.stdout.on('data', (data) => {
+        childProcess.stdout.on('data', (data) => {
             outputChannel.append(data.toString());
         });
 
-        process.stderr.on('data', (data) => {
+        childProcess.stderr.on('data', (data) => {
             hasError = true;
             outputChannel.append(data.toString());
         });
 
-        process.on('close', (code) => {
+        childProcess.on('close', (code) => {
             outputChannel.appendLine('');
             outputChannel.appendLine('─'.repeat(50));
             if (code === 0) {
@@ -79,7 +79,7 @@ function activate(context) {
             }
         });
 
-        process.on('error', (err) => {
+        childProcess.on('error', (err) => {
             outputChannel.appendLine(`[CSSL] Error: ${err.message}`);
             vscode.window.showErrorMessage(`Failed to run CSSL: ${err.message}. Make sure IncludeCPP is installed (pip install includecpp).`);
         });

includecpp/vscode/cssl/package.json

@@ -2,7 +2,7 @@
     "name": "cssl",
     "displayName": "CSSL Language",
     "description": "Professional syntax highlighting, snippets, and language support for CSSL scripts (.cssl, .cssl-pl, .cssl-mod)",
-    "version": "1.3.0",
+    "version": "1.6.0",
     "publisher": "IncludeCPP",
     "icon": "images/cssl.png",
     "engines": {

includecpp/vscode/cssl/snippets/cssl.snippets.json

@@ -1076,5 +1076,131 @@
             "}"
         ],
         "description": "Open parameter function"
+    },
+    "Undefined Function": {
+        "prefix": ["undefined", "undef"],
+        "body": [
+            "undefined ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Function with undefined modifier - suppresses all errors during execution"
+    },
+    "Private Function": {
+        "prefix": "private",
+        "body": [
+            "private ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Private function - disables all external injections"
+    },
+    "Closed Function": {
+        "prefix": "closed",
+        "body": [
+            "closed ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Closed function - protects from external injection modifications"
+    },
+    "Virtual Function": {
+        "prefix": "virtual",
+        "body": [
+            "virtual ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Virtual function - can be overridden in child classes"
+    },
+    "Meta Function": {
+        "prefix": "meta",
+        "body": [
+            "meta ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Meta function - metaprogramming function for code generation"
+    },
+    "Super Function": {
+        "prefix": "super",
+        "body": [
+            "super ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Super function - enhanced privileges for system-level operations"
+    },
+    "SQLBased Function": {
+        "prefix": "sqlbased",
+        "body": [
+            "sqlbased ${1:void} ${2:FuncName}(${3:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "SQL-based function - optimized for database operations"
+    },
+    "API Function with Modifiers": {
+        "prefix": ["apifunc", "globalapi"],
+        "body": [
+            "private super virtual meta ${1:GlobalApi}() {",
+            "\tinstance<\"${2:apiName}\"> api;",
+            "\tclass ${3:Api} {",
+            "\t\tdefine ${4:getMethod}() {",
+            "\t\t\t$0",
+            "\t\t}",
+            "\t}",
+            "\t%api +<== new ${3}();",
+            "\treturn %api;",
+            "}"
+        ],
+        "description": "Global API function with full modifiers and instance pattern"
+    },
+    "Combined Modifiers Function": {
+        "prefix": "modfunc",
+        "body": [
+            "${1|undefined,private,closed,virtual,meta,super,sqlbased|} ${2|undefined,private,closed,virtual,meta,super,sqlbased,void,int,string|} ${3:FuncName}(${4:params}) {",
+            "\t$0",
+            "}"
+        ],
+        "description": "Function with selectable modifier combinations"
+    },
+    "Python Pythonize": {
+        "prefix": ["python::pythonize", "pythonize"],
+        "body": "python::pythonize(${1:instance})$0",
+        "description": "Convert CSSL class instance to Python-usable object"
+    },
+    "Return Pythonized Class": {
+        "prefix": "returnpython",
+        "body": [
+            "${1:instance} = new ${2:ClassName}(${3:args});",
+            "pyobj = python::pythonize(${1});",
+            "parameter.return(pyobj);"
+        ],
+        "description": "Create class instance and return as Python object"
+    },
+    "Class with Python Export": {
+        "prefix": "pyclass",
+        "body": [
+            "class ${1:ClassName} {",
+            "\t${2:string} ${3:name};",
+            "",
+            "\t${1}(${4:params}) {",
+            "\t\tthis->${3} = ${5:value};",
+            "\t}",
+            "",
+            "\t${6:string} get${3/(.*)/${1:/capitalize}/}() {",
+            "\t\treturn this->${3};",
+            "\t}",
+            "",
+            "\tvoid set${3/(.*)/${1:/capitalize}/}(${2} newValue) {",
+            "\t\tthis->${3} = newValue;",
+            "\t}",
+            "}",
+            "",
+            "${7:obj} = new ${1}(${8:args});",
+            "parameter.return(python::pythonize(${7}));$0"
+        ],
+        "description": "Create a class and export as Python object"
     }
 }

includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -8,6 +8,9 @@
         { "include": "#strings" },
         { "include": "#numbers" },
         { "include": "#class-definition" },
+        { "include": "#function-definitions" },
+        { "include": "#constructor-definition" },
+        { "include": "#super-call" },
         { "include": "#sql-types" },
         { "include": "#keywords" },
         { "include": "#types" },
@@ -28,9 +31,63 @@
         { "include": "#builtins" },
         { "include": "#operators" },
         { "include": "#constants" },
+        { "include": "#non-null-declarations" },
         { "include": "#variables" }
     ],
     "repository": {
+        "non-null-declarations": {
+            "patterns": [
+                {
+                    "comment": "Non-null class: class *ClassName - turquoise",
+                    "name": "meta.class.non-null.cssl",
+                    "match": "\\b(class)\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.type.class.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "support.class.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Non-null function: define *FuncName - light pink",
+                    "name": "meta.function.non-null.cssl",
+                    "match": "\\b(define)\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Non-null typed variable: type<T> *varName - light pink",
+                    "name": "meta.declaration.non-null.cssl",
+                    "match": "\\b(int|string|float|bool|dynamic|vector|stack|array|list|dict|json|datastruct|iterator)\\s*(<[^>]+>)?\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.type.cssl" },
+                        "2": { "name": "storage.type.generic.cssl" },
+                        "3": { "name": "keyword.operator.non-null.cssl" },
+                        "4": { "name": "variable.other.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Non-null open parameter: open *Params - light pink",
+                    "name": "meta.parameter.non-null.cssl",
+                    "match": "\\b(open)\\s+(\\*)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.modifier.open.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "variable.parameter.non-null.cssl" }
+                    }
+                },
+                {
+                    "comment": "Return type -> * (non-null return)",
+                    "name": "meta.return-type.non-null.cssl",
+                    "match": "->\\s*\\*",
+                    "captures": {
+                        "0": { "name": "keyword.operator.non-null.return.cssl" }
+                    }
+                }
+            ]
+        },
         "super-functions": {
             "patterns": [
                 {
@@ -110,12 +167,74 @@
         },
         "class-definition": {
             "patterns": [
+                {
+                    "comment": "Class with extends AND overwrites: class X : extends Y : overwrites Z { }",
+                    "name": "meta.class.extends-overwrites.cssl",
+                    "begin": "\\b(class)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(overwrites)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?\\s*\\{",
+                    "beginCaptures": {
+                        "1": { "name": "storage.type.class.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "support.class.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "support.class.inherited.cssl" },
+                        "6": { "name": "storage.modifier.overwrites.cssl" },
+                        "7": { "name": "support.class.overwritten.cssl" }
+                    },
+                    "end": "\\}",
+                    "patterns": [
+                        { "include": "#comments" },
+                        { "include": "#constructor-definition" },
+                        { "include": "#class-method-definition" },
+                        { "include": "#class-member-declaration" },
+                        { "include": "#types" },
+                        { "include": "#this-access" },
+                        { "include": "#captured-references" },
+                        { "include": "#global-references" },
+                        { "include": "#shared-references" },
+                        { "include": "#strings" },
+                        { "include": "#numbers" },
+                        { "include": "#keywords" },
+                        { "include": "#function-calls" },
+                        { "include": "#builtins" },
+                        { "include": "#operators" }
+                    ]
+                },
+                {
+                    "comment": "Class with inheritance: class Child : extends Parent { }",
+                    "name": "meta.class.extends.cssl",
+                    "begin": "\\b(class)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)\\s*\\{",
+                    "beginCaptures": {
+                        "1": { "name": "storage.type.class.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "support.class.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "support.class.inherited.cssl" }
+                    },
+                    "end": "\\}",
+                    "patterns": [
+                        { "include": "#comments" },
+                        { "include": "#constructor-definition" },
+                        { "include": "#class-method-definition" },
+                        { "include": "#class-member-declaration" },
+                        { "include": "#types" },
+                        { "include": "#this-access" },
+                        { "include": "#captured-references" },
+                        { "include": "#global-references" },
+                        { "include": "#shared-references" },
+                        { "include": "#strings" },
+                        { "include": "#numbers" },
+                        { "include": "#keywords" },
+                        { "include": "#function-calls" },
+                        { "include": "#builtins" },
+                        { "include": "#operators" }
+                    ]
+                },
                 {
                     "name": "meta.class.cssl",
                     "begin": "\\b(class)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\{",
                     "beginCaptures": {
                         "1": { "name": "storage.type.class.cssl" },
-                        "2": { "name": "entity.name.class.cssl" }
+                        "2": { "name": "support.class.cssl" }
                     },
                     "end": "\\}",
                     "patterns": [
@@ -140,6 +259,28 @@
         },
         "constructor-definition": {
             "patterns": [
+                {
+                    "comment": "New-style constructor with constr keyword and extends: constr Name() :: extends Parent::Name { }",
+                    "name": "meta.constructor.constr.extends.cssl",
+                    "match": "\\b(constr)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\([^)]*\\)\\s*(::)?\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(::[a-zA-Z_][a-zA-Z0-9_]*)?",
+                    "captures": {
+                        "1": { "name": "storage.type.constructor.cssl" },
+                        "2": { "name": "entity.name.function.constructor.cssl" },
+                        "3": { "name": "punctuation.accessor.double-colon.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "entity.other.inherited-class.cssl" },
+                        "6": { "name": "entity.name.function.inherited.cssl" }
+                    }
+                },
+                {
+                    "comment": "New-style constructor with constr keyword: constr ConstructorName() { }",
+                    "name": "meta.constructor.constr.cssl",
+                    "match": "\\b(constr)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "storage.type.constructor.cssl" },
+                        "2": { "name": "entity.name.function.constructor.cssl" }
+                    }
+                },
                 {
                     "comment": "Constructor: ClassName { ... } or void ClassName(...)",
                     "name": "meta.constructor.cssl",
@@ -151,6 +292,28 @@
                 }
             ]
         },
+        "super-call": {
+            "patterns": [
+                {
+                    "comment": "super::method() - call parent method",
+                    "name": "meta.super-call.method.cssl",
+                    "match": "\\b(super)(::)([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "keyword.other.super.cssl" },
+                        "2": { "name": "punctuation.accessor.double-colon.cssl" },
+                        "3": { "name": "entity.name.function.parent.cssl" }
+                    }
+                },
+                {
+                    "comment": "super() - call parent constructor",
+                    "name": "meta.super-call.constructor.cssl",
+                    "match": "\\b(super)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "keyword.other.super.cssl" }
+                    }
+                }
+            ]
+        },
         "class-method-definition": {
             "patterns": [
                 {
@@ -209,6 +372,19 @@
                     "name": "storage.type.class.cssl",
                     "match": "\\b(class|struct|structure|enum|interface)\\b"
                 },
+                {
+                    "name": "storage.modifier.extends.cssl",
+                    "match": "\\b(extends|overwrites)\\b"
+                },
+                {
+                    "comment": "new ClassName() - class instantiation with turquoise class name",
+                    "name": "meta.new-expression.cssl",
+                    "match": "\\b(new)\\s+([A-Z][a-zA-Z0-9_]*)\\s*\\(",
+                    "captures": {
+                        "1": { "name": "keyword.operator.new.cssl" },
+                        "2": { "name": "support.class.cssl" }
+                    }
+                },
                 {
                     "name": "keyword.operator.new.cssl",
                     "match": "\\bnew\\b"
@@ -219,7 +395,11 @@
                 },
                 {
                     "name": "storage.type.function.cssl",
-                    "match": "\\b(define|void|shuffled)\\b"
+                    "match": "\\b(define|void|shuffled|constr)\\b"
+                },
+                {
+                    "name": "keyword.other.super.cssl",
+                    "match": "\\bsuper\\b"
                 },
                 {
                     "name": "keyword.other.cssl",
@@ -319,6 +499,14 @@
                 {
                     "name": "support.function.namespace.combo.cssl",
                     "match": "\\bcombo::(filterdb|blocked|like)\\b"
+                },
+                {
+                    "name": "support.function.namespace.python.cssl",
+                    "match": "\\bpython::(pythonize|wrap|export|csslize|import)\\b"
+                },
+                {
+                    "name": "support.function.namespace.filter.cssl",
+                    "match": "\\bfilter::(register|unregister|list|exists)\\b"
                 }
             ]
         },
@@ -453,6 +641,48 @@
                 }
             ]
         },
+        "function-definitions": {
+            "patterns": [
+                {
+                    "comment": "Function with extends AND overwrites: define func : extends X : overwrites Y() { }",
+                    "name": "meta.function.extends-overwrites.cssl",
+                    "match": "\\b(define)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?\\s*:\\s*(overwrites)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "entity.other.inherited-function.cssl" },
+                        "7": { "name": "storage.modifier.overwrites.cssl" },
+                        "8": { "name": "entity.other.overwritten-function.cssl" }
+                    }
+                },
+                {
+                    "comment": "Function with extends: define func : extends otherFunc() { }",
+                    "name": "meta.function.extends.cssl",
+                    "match": "\\b(define)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(extends)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.cssl" },
+                        "4": { "name": "storage.modifier.extends.cssl" },
+                        "5": { "name": "entity.other.inherited-function.cssl" }
+                    }
+                },
+                {
+                    "comment": "Function with overwrites: define func : overwrites target() { }",
+                    "name": "meta.function.overwrites.cssl",
+                    "match": "\\b(define)\\s+(\\*?)([a-zA-Z_][a-zA-Z0-9_]*)\\s*:\\s*(overwrites)\\s+(\\$?[a-zA-Z_][a-zA-Z0-9_]*)(\\(\\))?",
+                    "captures": {
+                        "1": { "name": "storage.type.function.cssl" },
+                        "2": { "name": "keyword.operator.non-null.cssl" },
+                        "3": { "name": "entity.name.function.cssl" },
+                        "4": { "name": "storage.modifier.overwrites.cssl" },
+                        "5": { "name": "entity.other.overwritten-function.cssl" }
+                    }
+                }
+            ]
+        },
         "function-calls": {
             "patterns": [
                 {