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

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.
 

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

@@ -435,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",
@@ -568,6 +568,42 @@
         },
         "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|const|static|final|abstract|readonly)\\b"

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
+```

{includecpp-4.2.2.dist-info → includecpp-4.3.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-includecpp/CHANGELOG.md,sha256=vvu64zkKSGOGmyRVp6sYRi8fhOxStU6TzwgjoV30BAs,5732
-includecpp/DOCUMENTATION.md,sha256=DuDN5EesEv9h-uTgJpNNBTi3R-RibXjrGfIKUK6uEg0,9762
-includecpp/__init__.py,sha256=H919cTs7I9eEHaskdRMmBob6NLdoOpJfHYskGwhwsdM,1672
+includecpp/CHANGELOG.md,sha256=fLSeIacvnmG-Ea8XUnvtvMdgAWfcQW0uybkldXaxsoc,3621
+includecpp/DOCUMENTATION.md,sha256=MgCUZtslObxTqTLnxjME34NcGo4Z1h_C3n6gcDs82r0,7961
+includecpp/__init__.py,sha256=CIHeXGlukGABoueKCmFPIhOjubjZvOs6OG2vYJkAjPo,1672
 includecpp/__init__.pyi,sha256=gfpArSojafkBCUoACntpnPBVgKLPZHecsyJtlVhE1A0,7267
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 includecpp/cli/__init__.py,sha256=Yda-4a5QJb_tKu35YQNfc5lu-LewTsM5abqNNkzS47M,113
-includecpp/cli/commands.py,sha256=7Cu1zgXmK6ghOebzKqTwZHXvROHWpqiYHKnrBW3g0ZA,372152
+includecpp/cli/commands.py,sha256=vwmWCKPOI7WFC_hSBdBL3ELr7GB1lQDymoGjdRfB_uQ,372181
 includecpp/cli/config_parser.py,sha256=KveeYUg2TA9sC5hKVzYYfgdNm2WfLG5y7_yxgBWn9yM,4886
 includecpp/core/__init__.py,sha256=L1bT6oikTjdto-6Px7DpjePtM07ymo3Bnov1saZzsGg,390
 includecpp/core/ai_integration.py,sha256=Q44Y1SD_4yXETO4AwtoR51QnX0T4Tc14_Ux9VozQJhQ,89146
@@ -22,18 +22,18 @@ includecpp/core/exceptions.py,sha256=szeF4qdzi_q8hBBZi7mJxkliyQ0crplkLYe0ymlBGtk
 includecpp/core/path_discovery.py,sha256=jI0oSq6Hsd4LKXmU4dOiGSrXcEO_KWMXfQ5_ylBmXvU,2561
 includecpp/core/project_ui.py,sha256=la2EQZKmUkJGuJxnbs09hH1ZhBh9bfndo6okzZsk2dQ,141134
 includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCEQ,11798
-includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=M55jgDBNrgjcLQHpdN5KbHvwLWgV7SQBGEAGEFFmNCo,36847
+includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=Ax7x6h_ZFg4rhghtSNG9dahySh-bJc2upEqP4E-mfck,43486
 includecpp/core/cssl/CSSL_DOCUMENTATION_NEW.md,sha256=I_bVeKWlbcgHYkl2o9L2vk3r5sDvG44bGh__RJIYduw,28222
 includecpp/core/cssl/__init__.py,sha256=scDXRBNK2L6A8qmlpNyaqQj6BFcSfPInBlucdeNfMF0,1975
-includecpp/core/cssl/cssl_builtins.py,sha256=x8bKQ2WEzxjkFWmGb6dK2jggiylkj04-6f15iDwEi_U,108791
+includecpp/core/cssl/cssl_builtins.py,sha256=1JZpOdLOJawc-ZlKwAA9Ff4BwlrCweLfG9bfMbjF6H8,114033
 includecpp/core/cssl/cssl_builtins.pyi,sha256=-yr9JbxHKFv9Vc1iufChcqCQvNQLL3-Ow_Hgg0YwQnc,135180
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_languages.py,sha256=qftMcBiNT1pbIn5OniTZDx8rFtGYU4yx4Iw1QYKAC1U,62342
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
-includecpp/core/cssl/cssl_parser.py,sha256=ZceGO7M2DJWt1aAORlsRWliKo3E-tcMRLs6GFEx46jg,170350
-includecpp/core/cssl/cssl_runtime.py,sha256=6jz6XnjjEZlWDuHxUhiiuM3HwkT4Ah74yRQqUCfw_KY,237635
+includecpp/core/cssl/cssl_parser.py,sha256=sureKmhbA1mxn21LJ_A-tRK49vrM8SvfF_X-4kEsmTg,193366
+includecpp/core/cssl/cssl_runtime.py,sha256=GmeR7hlZpAgikoeSVz7BH8w5CmmXCWfBRLl8VNrZSyk,257539
 includecpp/core/cssl/cssl_syntax.py,sha256=AcFvqCB9WKitNA32izCWf5jeFWNc6ncc-xLw0J5UjBg,20933
-includecpp/core/cssl/cssl_types.py,sha256=Vs61dnMh8iUxVu7LPz8HM-XyojuQptykkedlVA3J2Bc,60031
+includecpp/core/cssl/cssl_types.py,sha256=wLS2gj9sibklRqnqaZYQC_AsSsopJtBj8WTEmSDLo1g,67149
 includecpp/generator/__init__.py,sha256=Rsy41bwimaEloD3gDRR_znPfIJzIsCFuWZgCTJBLJlc,62
 includecpp/generator/parser.cpp,sha256=KT_rrZFJi8KF6emstIW5lKOMaD5gOTC9IcrGEIuIuYw,83251
 includecpp/generator/parser.h,sha256=z8qHnsiY8cXAwq5JW9O-V-hCSjDQacYLgi91ViqzHSw,11405
@@ -48,10 +48,10 @@ includecpp/vscode/cssl/package.json,sha256=u5iHl79-GfeJiQ7vPe8DP5hXlOpGP41d1A54b
 includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86MsvUGlSZw,510
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=uV3nHJyQ5f7Pr3FzfbQT2VZOEY3AlGs4wrmqe884jm4,37372
-includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=nYy7aRWREcgCu9Jbx5QmtQHfD4WRlk-HkPhqzKVtoIA,42806
-includecpp-4.2.2.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-4.2.2.dist-info/METADATA,sha256=g45uGNc1c5Ey2qBgfSXKIvIfn7YK4RhHn6OPtf69hlw,24887
-includecpp-4.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-4.2.2.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-4.2.2.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-4.2.2.dist-info/RECORD,,
+includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=IMDF2IqTh-jXx6x5lVfShDmJb5cRVIuJ70P30ahwkME,44674
+includecpp-4.3.0.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-4.3.0.dist-info/METADATA,sha256=9C2fO6sSgyjMy3AKk_lEU4zt4MiCEqJ9gL5cQzsUhdA,5887
+includecpp-4.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-4.3.0.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-4.3.0.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-4.3.0.dist-info/RECORD,,