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

includecpp/generator/parser.h

@@ -127,6 +127,7 @@ struct VariableBinding {
 };
 
 // v2.0: STRUCT() Bindings for Plain-Old-Data types
+// v4.1.1: Added CONSTRUCTOR and METHOD support (same as CLASS)
 struct StructBinding {
     std::string module_name;
     std::string struct_name;
@@ -135,6 +136,11 @@ struct StructBinding {
     bool is_template = false;
     std::string documentation;
 
+    // v4.1.1: CONSTRUCTOR and METHOD support for STRUCT (same as CLASS)
+    std::vector<ConstructorInfo> constructors;
+    std::vector<MethodSignature> method_signatures;
+    std::vector<std::string> methods;  // Simple method names for backward compatibility
+
     // Helper methods
     std::string get_full_name() const {
         return struct_name;

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.6.0",
+    "version": "1.7.1",
     "publisher": "IncludeCPP",
     "icon": "images/cssl.png",
     "engines": {
@@ -151,6 +151,48 @@
                     "description": "Show output panel when running CSSL files"
                 }
             }
+        },
+        "configurationDefaults": {
+            "editor.tokenColorCustomizations": {
+                "textMateRules": [
+                    {
+                        "scope": "storage.modifier.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "storage.modifier.extends.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "storage.modifier.overwrites.cssl",
+                        "settings": {
+                            "fontStyle": "italic"
+                        }
+                    },
+                    {
+                        "scope": "support.type.cssl",
+                        "settings": {
+                            "foreground": "#C586C0"
+                        }
+                    },
+                    {
+                        "scope": "variable.other.declaration.cssl",
+                        "settings": {
+                            "foreground": "#9CDCFE"
+                        }
+                    },
+                    {
+                        "scope": "variable.parameter.cssl",
+                        "settings": {
+                            "foreground": "#9CDCFE"
+                        }
+                    }
+                ]
+            }
         }
     }
 }

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

@@ -15,6 +15,7 @@
         { "include": "#super-call" },
         { "include": "#sql-types" },
         { "include": "#keywords" },
+        { "include": "#typed-declarations" },
         { "include": "#types" },
         { "include": "#function-modifiers" },
         { "include": "#injection-operators" },
@@ -211,17 +212,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 },
                 {
@@ -241,17 +246,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 },
                 {
@@ -267,17 +276,21 @@
                         { "include": "#constructor-definition" },
                         { "include": "#class-method-definition" },
                         { "include": "#class-member-declaration" },
+                        { "include": "#typed-declarations" },
                         { "include": "#types" },
+                        { "include": "#function-modifiers" },
                         { "include": "#this-access" },
                         { "include": "#captured-references" },
                         { "include": "#global-references" },
                         { "include": "#shared-references" },
+                        { "include": "#instance-references" },
                         { "include": "#strings" },
                         { "include": "#numbers" },
                         { "include": "#keywords" },
                         { "include": "#function-calls" },
                         { "include": "#builtins" },
-                        { "include": "#operators" }
+                        { "include": "#operators" },
+                        { "include": "#constants" }
                     ]
                 }
             ]
@@ -354,11 +367,42 @@
         "class-member-declaration": {
             "patterns": [
                 {
+                    "comment": "Generic type member: datastruct<dynamic> Container;",
+                    "name": "meta.member.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type member: string ApiID;",
                     "name": "meta.member.cssl",
-                    "match": "\\b(int|string|float|bool|dynamic|auto)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "match": "\\b(int|string|float|bool|dynamic|auto|void|json|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
                     "captures": {
-                        "1": { "name": "storage.type.cssl" },
-                        "2": { "name": "variable.other.member.cssl" }
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Container type member without generic: list items;",
+                    "name": "meta.member.container.cssl",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*;",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type member with assignment: string ApiID = value;",
+                    "name": "meta.member.assigned.cssl",
+                    "match": "\\b(int|string|float|bool|dynamic|auto|void|json|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*=",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
                     }
                 }
             ]
@@ -391,11 +435,11 @@
             "patterns": [
                 {
                     "name": "keyword.control.cssl",
-                    "match": "\\b(if|else|elif|while|for|foreach|in|range|switch|case|default|break|continue|return|try|catch|finally|throw)\\b"
+                    "match": "\\b(if|else|elif|while|for|foreach|in|range|switch|case|default|break|continue|return|try|catch|finally|throw|except|always)\\b"
                 },
                 {
                     "name": "storage.type.class.cssl",
-                    "match": "\\b(class|struct|structure|enum|interface)\\b"
+                    "match": "\\b(class|struct|structure|enum|interface|bytearrayed)\\b"
                 },
                 {
                     "name": "storage.modifier.extends.cssl",
@@ -440,10 +484,65 @@
                 }
             ]
         },
+        "typed-declarations": {
+            "patterns": [
+                {
+                    "comment": "Generic type declaration: datastruct<dynamic> Container; or vector<int> items;",
+                    "name": "meta.declaration.typed.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type declaration: string ID; or int count;",
+                    "name": "meta.declaration.typed.primitive.cssl",
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[;=])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Container type declaration without generic: list items;",
+                    "name": "meta.declaration.typed.container.cssl",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[;=])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "Generic type in function parameter: func(datastruct<dynamic> param)",
+                    "name": "meta.parameter.typed.generic.cssl",
+                    "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[,)])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.parameter.cssl" }
+                    }
+                },
+                {
+                    "comment": "Primitive type in function parameter: func(string name)",
+                    "name": "meta.parameter.typed.primitive.cssl",
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?=[,)])",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "variable.parameter.cssl" }
+                    }
+                }
+            ]
+        },
         "types": {
             "patterns": [
                 {
-                    "name": "storage.type.primitive.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\b"
                 },
                 {
@@ -451,27 +550,63 @@
                     "name": "meta.generic.cssl",
                     "match": "(\\b(?:array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|tuple|set|queue))(<)([^>]+)(>)",
                     "captures": {
-                        "1": { "name": "storage.type.container.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
-                        "3": { "name": "storage.type.parameter.cssl" },
+                        "3": { "name": "support.type.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 },
                 {
-                    "name": "storage.type.container.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance|tuple|set|queue)\\b"
                 },
                 {
-                    "name": "storage.type.combo-open.cssl",
+                    "name": "support.type.cssl",
                     "match": "\\bcombo\\s*<\\s*open\\s*&"
                 }
             ]
         },
         "function-modifiers": {
             "patterns": [
+                {
+                    "comment": "embedded keyword - italic, darker purple/magenta",
+                    "name": "keyword.control.embedded.cssl",
+                    "match": "\\b(embedded)\\s+(?=(class|[a-zA-Z_]))",
+                    "captures": {
+                        "1": { "name": "keyword.control.embedded.cssl" }
+                    }
+                },
+                {
+                    "comment": "embedded function/class name - same color as switch",
+                    "name": "meta.embedded.definition.cssl",
+                    "match": "\\b(embedded)\\s+(class\\s+)?([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "keyword.control.embedded.cssl" },
+                        "2": { "name": "storage.type.class.cssl" },
+                        "3": { "name": "keyword.control.cssl" }
+                    }
+                },
+                {
+                    "comment": "open ParamName - ParamName in orange",
+                    "name": "meta.open.parameter.cssl",
+                    "match": "\\b(open)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "storage.modifier.cssl" },
+                        "2": { "name": "constant.character.escape.infuse.cssl" }
+                    }
+                },
+                {
+                    "comment": "switch(variable) - variable in orange",
+                    "name": "meta.switch.expression.cssl",
+                    "match": "\\b(switch)\\s*\\(\\s*([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\)",
+                    "captures": {
+                        "1": { "name": "keyword.control.cssl" },
+                        "2": { "name": "constant.character.escape.infuse.cssl" }
+                    }
+                },
                 {
                     "name": "storage.modifier.cssl",
-                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited)\\b"
+                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited|const|static|final|abstract|readonly)\\b"
                 }
             ]
         },
@@ -619,24 +754,48 @@
         "instance-references": {
             "patterns": [
                 {
-                    "comment": "instance<\"name\"> - shared instance reference with string",
+                    "comment": "instance<\"name\"> varName - shared instance declaration with variable",
+                    "name": "meta.instance.declaration.cssl",
+                    "match": "(\\binstance)(<)(\"[^\"]+\")(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "string.quoted.double.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "instance<Type> varName - shared instance declaration with type and variable",
+                    "name": "meta.instance.declaration.cssl",
+                    "match": "(\\binstance)(<)([a-zA-Z_][a-zA-Z0-9_]*)(>)\\s+([a-zA-Z_][a-zA-Z0-9_]*)",
+                    "captures": {
+                        "1": { "name": "support.type.cssl" },
+                        "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
+                        "3": { "name": "support.type.cssl" },
+                        "4": { "name": "punctuation.definition.typeparameters.end.cssl" },
+                        "5": { "name": "variable.other.declaration.cssl" }
+                    }
+                },
+                {
+                    "comment": "instance<\"name\"> - shared instance reference without variable",
                     "name": "meta.instance.cssl",
                     "match": "(\\binstance)(<)(\"[^\"]+\")(>)",
                     "captures": {
-                        "1": { "name": "storage.type.instance.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
                         "3": { "name": "string.quoted.double.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 },
                 {
-                    "comment": "instance<Type> - shared instance reference with type",
+                    "comment": "instance<Type> - shared instance reference without variable",
                     "name": "meta.instance.cssl",
                     "match": "(\\binstance)(<)([a-zA-Z_][a-zA-Z0-9_]*)(>)",
                     "captures": {
-                        "1": { "name": "storage.type.instance.cssl" },
+                        "1": { "name": "support.type.cssl" },
                         "2": { "name": "punctuation.definition.typeparameters.begin.cssl" },
-                        "3": { "name": "entity.name.type.cssl" },
+                        "3": { "name": "support.type.cssl" },
                         "4": { "name": "punctuation.definition.typeparameters.end.cssl" }
                     }
                 }

includecpp-4.3.0.dist-info/METADATA

@@ -0,0 +1,277 @@
+Metadata-Version: 2.4
+Name: IncludeCPP
+Version: 4.3.0
+Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
+Home-page: https://github.com/liliassg/IncludeCPP
+Author: Lilias Hatterscheidt
+Author-email: Lilias Hatterscheidt <hatterscheidt.lilias@gmail.com>
+License: MIT
+Project-URL: Repository, https://github.com/liliassg/IncludeCPP
+Project-URL: Bug Tracker, https://github.com/liliassg/IncludeCPP/issues
+Keywords: c++,python,bindings,pybind11,template,performance,threading
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pybind11>=2.11.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: colorama>=0.4.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# IncludeCPP
+
+Use C++ code in Python. Write your C++ functions and classes, IncludeCPP generates the Python bindings automatically.
+
+```bash
+pip install IncludeCPP
+```
+
+## Quick Start
+
+### 1. Create a Project
+
+```bash
+mkdir myproject && cd myproject
+includecpp init
+```
+
+This creates:
+- `cpp.proj` - your project settings
+- `include/` - put your C++ files here
+- `plugins/` - binding files go here (auto-generated)
+
+### 2. Write Some C++
+
+Create `include/math.cpp`:
+
+```cpp
+namespace includecpp {
+
+int add(int a, int b) {
+    return a + b;
+}
+
+int multiply(int a, int b) {
+    return a * b;
+}
+
+}
+```
+
+Your code must be inside `namespace includecpp`. Everything outside is ignored.
+
+### 3. Generate Bindings
+
+```bash
+includecpp plugin math include/math.cpp
+```
+
+This scans your C++ and creates `plugins/math.cp` with the binding instructions.
+
+### 4. Build
+
+```bash
+includecpp rebuild
+```
+
+Compiles your C++ into a Python module.
+
+### 5. Use in Python
+
+```python
+from includecpp import math
+
+print(math.add(2, 3))       # 5
+print(math.multiply(4, 5))  # 20
+```
+
+Done. Your C++ code works in Python.
+
+---
+
+## Classes
+
+C++ classes work the same way:
+
+```cpp
+// include/calculator.cpp
+#include <vector>
+
+namespace includecpp {
+
+class Calculator {
+public:
+    Calculator() : result(0) {}
+
+    void add(int x) { result += x; }
+    void subtract(int x) { result -= x; }
+    int getResult() { return result; }
+    void reset() { result = 0; }
+
+private:
+    int result;
+};
+
+}
+```
+
+Generate and build:
+
+```bash
+includecpp plugin calculator include/calculator.cpp
+includecpp rebuild
+```
+
+Use in Python:
+
+```python
+from includecpp import calculator
+
+calc = calculator.Calculator()
+calc.add(10)
+calc.add(5)
+calc.subtract(3)
+print(calc.getResult())  # 12
+```
+
+---
+
+## Development Workflow
+
+When you're actively working on your C++:
+
+```bash
+# Regenerate bindings AND rebuild in one command
+includecpp auto math
+
+# Fast rebuild (skips unchanged files, ~0.4s when nothing changed)
+includecpp rebuild --fast
+
+# Rebuild everything from scratch
+includecpp rebuild --clean
+```
+
+---
+
+## CLI Commands
+
+| Command | What it does |
+|---------|-------------|
+| `init` | Create project structure |
+| `plugin <name> <file.cpp>` | Generate bindings from C++ |
+| `auto <name>` | Regenerate bindings + rebuild |
+| `rebuild` | Compile all modules |
+| `rebuild --fast` | Fast incremental build |
+| `rebuild --clean` | Full clean rebuild |
+| `get <name>` | Show module's API |
+
+---
+
+## Project Configuration
+
+The `cpp.proj` file controls your build:
+
+```json
+{
+  "project": "MyProject",
+  "include": "/include",
+  "plugins": "/plugins",
+  "compiler": {
+    "standard": "c++17",
+    "optimization": "O3"
+  }
+}
+```
+
+---
+
+## Plugin Files (.cp)
+
+The `.cp` files tell IncludeCPP what to expose. They're auto-generated, but you can edit them:
+
+```
+SOURCE(calculator.cpp) calculator
+
+PUBLIC(
+    calculator CLASS(Calculator) {
+        CONSTRUCTOR()
+        METHOD(add)
+        METHOD(subtract)
+        METHOD(getResult)
+        METHOD(reset)
+    }
+)
+```
+
+Common directives:
+- `CLASS(Name)` - expose a class
+- `METHOD(name)` - expose a method
+- `FUNC(name)` - expose a function
+- `FIELD(name)` - expose a member variable
+- `CONSTRUCTOR()` or `CONSTRUCTOR(int, string)` - expose constructor
+
+---
+
+## Requirements
+
+- Python 3.9+
+- C++ compiler (g++, clang++, or MSVC)
+- CMake
+
+pybind11 is installed automatically.
+
+---
+
+## More Help
+
+```bash
+includecpp --doc           # Full documentation
+includecpp --changelog     # Version history
+includecpp <command> --help
+```
+
+---
+
+## Experimental Features
+
+IncludeCPP also includes experimental features that are still in development:
+
+- **CSSL** - A scripting language for runtime code manipulation
+- **AI Commands** - OpenAI-powered code analysis (`includecpp ai`)
+- **CPPY** - Python to C++ conversion (`includecpp cppy`)
+
+These are hidden by default. To enable them:
+
+```bash
+includecpp settings
+```
+
+Check "Enable Experimental Features" and save.
+
+Warning: Experimental features may have bugs or breaking changes between versions.
+
+---
+
+## Issues
+
+Report bugs at: https://github.com/liliassg/IncludeCPP/issues
+
+```bash
+includecpp bug    # Quick bug report
+includecpp update # Update to latest version
+```