IncludeCPP 3.7.5__tar.gz → 3.7.6__tar.gz

{includecpp-3.7.5 → includecpp-3.7.6}/IncludeCPP.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.5
+Version: 3.7.6
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.7.5 → includecpp-3.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.5
+Version: 3.7.6
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.7.5 → includecpp-3.7.6}/includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "3.7.5"
+__version__ = "3.7.6"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

{includecpp-3.7.5 → includecpp-3.7.6}/includecpp/cli/commands.py

@@ -7480,13 +7480,12 @@ def cssl_exec(path, code):
     # Execute
     click.secho("--- Output ---", fg='green')
     try:
-        result = cssl_lang.exec(source)
+        result = cssl_lang.run(source)
 
         # Output is already printed to stdout during execution via runtime.output()
-        # No need to print buffer again - this was causing double output
-
-        if result is not None:
-            click.echo(f"Result: {result}")
+        # Don't print "Result:" automatically - users should use printl() for output
+        # This prevents unwanted output for function calls like: Function();
+        pass
 
     except Exception as e:
         click.secho(f"CSSL Error: {e}", fg='red')
@@ -7595,75 +7594,95 @@ def cssl_doc(search, list_sections):
             click.secho("=" * 50, fg='cyan')
             click.echo()
 
-            # Split into sections (## headers)
-            sections = re.split(r'(?=^## )', content, flags=re.MULTILINE)
-
-            found_sections = []
-            for section in sections:
-                if search.lower() in section.lower():
-                    found_sections.append(section)
-
-            if found_sections:
-                # Also find specific lines with the search term
-                all_lines = content.split('\n')
-                matching_lines = []
-                for i, line in enumerate(all_lines):
-                    if search.lower() in line.lower():
-                        # Get context (2 lines before and after)
-                        start = max(0, i - 2)
-                        end = min(len(all_lines), i + 3)
-                        context = '\n'.join(all_lines[start:end])
-                        if context not in matching_lines:
-                            matching_lines.append((i + 1, context))
-
-                # Show summary
-                click.secho(f"Found in {len(found_sections)} section(s):", fg='green')
-                for section in found_sections:
-                    # Extract section title
-                    title_match = re.match(r'^##\s+(.+)$', section, re.MULTILINE)
-                    if title_match:
-                        click.echo(f"  - {title_match.group(1)}")
+            # Split into subsections (### headers) for focused results
+            subsections = re.split(r'(?=^### )', content, flags=re.MULTILINE)
 
-                click.echo()
+            # Also split into main sections (## headers)
+            main_sections = re.split(r'(?=^## )', content, flags=re.MULTILINE)
 
-                # Show matching contexts with highlighting
-                click.secho("Matching content:", fg='yellow', bold=True)
-                click.secho("-" * 50, fg='yellow')
+            # Find matching subsections (### level) - most focused
+            matching_subsections = []
+            for subsection in subsections:
+                if search.lower() in subsection.lower():
+                    # Extract title
+                    title_match = re.match(r'^###\s+(.+)$', subsection, re.MULTILINE)
+                    if title_match:
+                        # Trim subsection to just the content until next ### or ##
+                        lines = subsection.split('\n')
+                        trimmed_lines = []
+                        for line in lines:
+                            if line.startswith('## ') and not line.startswith('### '):
+                                break
+                            trimmed_lines.append(line)
+                        matching_subsections.append((title_match.group(1), '\n'.join(trimmed_lines)))
+
+            if matching_subsections:
+                click.secho(f"Found {len(matching_subsections)} matching subsection(s):", fg='green')
+                click.echo()
 
-                for line_num, context in matching_lines[:15]:  # Limit to 15 matches
-                    click.echo(f"\nLine {line_num}:")
-                    # Highlight the search term
+                # Show focused subsections (limit output)
+                for title, sub_content in matching_subsections[:5]:
+                    click.secho(f"### {title}", fg='yellow', bold=True)
+                    # Highlight search term in content
                     highlighted = re.sub(
                         f'({re.escape(search)})',
                         click.style(r'\1', fg='green', bold=True),
-                        context,
+                        sub_content,
                         flags=re.IGNORECASE
                     )
-                    click.echo(highlighted)
-                    click.echo("-" * 30)
-
-                if len(matching_lines) > 15:
-                    click.echo(f"\n... and {len(matching_lines) - 15} more matches")
-
-                # Offer to show full sections
-                click.echo()
-                click.secho("Full sections containing your search:", fg='cyan')
-                click.echo("(Scroll or pipe to a file for full content)")
-                click.echo()
-
-                for section in found_sections:
-                    click.echo(section)
+                    # Limit lines per subsection
+                    lines = highlighted.split('\n')
+                    if len(lines) > 30:
+                        click.echo('\n'.join(lines[:30]))
+                        click.secho(f"  ... ({len(lines) - 30} more lines)", fg='cyan')
+                    else:
+                        click.echo(highlighted)
+                    click.echo()
+                    click.secho("-" * 40, fg='cyan')
                     click.echo()
 
+                if len(matching_subsections) > 5:
+                    click.secho(f"... and {len(matching_subsections) - 5} more subsections", fg='cyan')
+                    click.echo("Use --list to see all sections")
             else:
-                click.secho(f"No matches found for '{search}'", fg='yellow')
-                click.echo()
-                click.echo("Try searching for:")
-                click.echo("  - Keywords: class, function, define, open, global")
-                click.echo("  - Syntax: $, @, ::, this->, <<==, <==")
-                click.echo("  - Types: string, int, stack, vector, map, json")
-                click.echo()
-                click.echo("Or use: includecpp cssl doc --list")
+                # Fall back to main section search (## level)
+                found_sections = []
+                for section in main_sections:
+                    if search.lower() in section.lower():
+                        title_match = re.match(r'^##\s+(.+)$', section, re.MULTILINE)
+                        if title_match:
+                            found_sections.append((title_match.group(1), section))
+
+                if found_sections:
+                    click.secho(f"Found in {len(found_sections)} section(s):", fg='green')
+                    for title, _ in found_sections:
+                        click.echo(f"  - {title}")
+                    click.echo()
+
+                    # Show first matching section, trimmed
+                    title, section = found_sections[0]
+                    click.secho(f"## {title}", fg='yellow', bold=True)
+                    highlighted = re.sub(
+                        f'({re.escape(search)})',
+                        click.style(r'\1', fg='green', bold=True),
+                        section,
+                        flags=re.IGNORECASE
+                    )
+                    lines = highlighted.split('\n')
+                    if len(lines) > 40:
+                        click.echo('\n'.join(lines[:40]))
+                        click.secho(f"\n... ({len(lines) - 40} more lines in this section)", fg='cyan')
+                    else:
+                        click.echo(highlighted)
+                else:
+                    click.secho(f"No matches found for '{search}'", fg='yellow')
+                    click.echo()
+                    click.echo("Try searching for:")
+                    click.echo("  - Keywords: class, function, define, open, global, shuffled")
+                    click.echo("  - Syntax: $, @, ::, this->, <<==, <==, #$")
+                    click.echo("  - Types: string, int, stack, vector, map, json")
+                    click.echo()
+                    click.echo("Or use: includecpp cssl doc --list")
         else:
             # Full documentation mode
             click.echo_via_pager(content)

{includecpp-3.7.5 → includecpp-3.7.6}/includecpp/core/cssl/CSSL_DOCUMENTATION.md

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.7.2 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.7.6 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
 
 ---
 
@@ -41,22 +41,25 @@
 ```python
 from includecpp import CSSL
 
-# Initialize CSSL
-CSSL.CsslLang()
-
-# Execute code
-CSSL.exec("""
+# Execute code (v3.7.6+: use run() instead of exec())
+CSSL.run("""
     printl("Hello CSSL!");
 """)
 
 # With parameters and return value
-result = CSSL.exec("""
+result = CSSL.run("""
     string name = parameter.get(0);
     printl("Hello " + name);
     parameter.return(true);
 """, "World")
 
 print(result)  # True
+
+# Create typed scripts and modules (v3.7.6+)
+main = CSSL.script("cssl", '''printl("Main");''')
+payload = CSSL.script("cssl-pl", '''void helper() { printl("Helper!"); }''')
+mod = CSSL.makemodule(main, payload, "mymod")
+mod.helper()  # Call function directly
 ```
 
 ### CLI Execution
@@ -701,12 +704,24 @@ super void forceRun() {
 
 ### shuffled
 
-Allows multiple return values.
+Allows multiple return values with tuple unpacking.
 
 ```cssl
 shuffled string getNames() {
     return "Alice", "Bob", "Charlie";
 }
+
+// Tuple unpacking (v3.7.6+)
+a, b, c = getNames();
+printl(a);  // "Alice"
+printl(b);  // "Bob"
+printl(c);  // "Charlie"
+
+// Works with any types
+shuffled getValues() {
+    return "text", 42, true;
+}
+name, num, flag = getValues();
 ```
 
 ---
@@ -1143,6 +1158,10 @@ print(stats.total)  # 50 - Persisted!
 
 CodeInfusion enables modifying functions at runtime.
 
+> **Important**: Injection operators must be written **without spaces**:
+> - ✓ `func() <<==` / `func() +<<==` / `func() -<<==` (correct)
+> - ✗ `func() < <==` / `func() + <<==` / `func() - <<==` (wrong)
+
 ### <<== (Replace)
 
 Replaces function content.

{includecpp-3.7.5 → includecpp-3.7.6}/includecpp/core/cssl/cssl_parser.py

@@ -1776,11 +1776,31 @@ class CSSLParser:
         return node
 
     def _parse_return(self) -> ASTNode:
-        value = None
+        """Parse return statement, supporting multiple values for shuffled functions.
+
+        Syntax:
+            return;                    // Return None
+            return value;              // Return single value
+            return a, b, c;            // Return multiple values (for shuffled)
+        """
+        values = []
         if not self._check(TokenType.SEMICOLON) and not self._check(TokenType.BLOCK_END):
-            value = self._parse_expression()
+            values.append(self._parse_expression())
+
+            # Check for comma-separated return values (shuffled return)
+            while self._check(TokenType.COMMA):
+                self._advance()  # consume comma
+                values.append(self._parse_expression())
+
         self._match(TokenType.SEMICOLON)
-        return ASTNode('return', value=value)
+
+        if len(values) == 0:
+            return ASTNode('return', value=None)
+        elif len(values) == 1:
+            return ASTNode('return', value=values[0])
+        else:
+            # Multiple return values - create tuple return
+            return ASTNode('return', value={'multiple': True, 'values': values})
 
     def _parse_super_function(self) -> ASTNode:
         """Parse super-function for .cssl-pl payload files.
@@ -1892,6 +1912,25 @@ class CSSLParser:
     def _parse_expression_statement(self) -> Optional[ASTNode]:
         expr = self._parse_expression()
 
+        # === TUPLE UNPACKING: a, b, c = shuffled_func() ===
+        # Check if we have comma-separated identifiers before =
+        if expr.type == 'identifier' and self._check(TokenType.COMMA):
+            targets = [expr]
+            while self._match(TokenType.COMMA):
+                next_expr = self._parse_expression()
+                if next_expr.type == 'identifier':
+                    targets.append(next_expr)
+                else:
+                    # Not a simple identifier list, this is something else
+                    # Restore and fall through to normal parsing
+                    break
+
+            # Check if followed by =
+            if self._match(TokenType.EQUALS):
+                value = self._parse_expression()
+                self._match(TokenType.SEMICOLON)
+                return ASTNode('tuple_assignment', value={'targets': targets, 'value': value})
+
         # === BASIC INJECTION: <== (replace target with source) ===
         if self._match(TokenType.INJECT_LEFT):
             # Check if this is a createcmd injection with a code block

{includecpp-3.7.5 → includecpp-3.7.6}/includecpp/core/cssl/cssl_runtime.py

@@ -1186,8 +1186,20 @@ class CSSLRuntime:
         return None
 
     def _exec_return(self, node: ASTNode) -> Any:
-        """Execute return statement"""
-        value = self._evaluate(node.value) if node.value else None
+        """Execute return statement.
+
+        Supports multiple return values for shuffled functions:
+            return a, b, c;  // Returns tuple (a, b, c)
+        """
+        if node.value is None:
+            raise CSSLReturn(None)
+
+        # Check if this is a multiple return value
+        if isinstance(node.value, dict) and node.value.get('multiple'):
+            values = [self._evaluate(v) for v in node.value.get('values', [])]
+            raise CSSLReturn(tuple(values))
+
+        value = self._evaluate(node.value)
         raise CSSLReturn(value)
 
     def _exec_break(self, node: ASTNode) -> Any:
@@ -1814,6 +1826,36 @@ class CSSLRuntime:
 
         return value
 
+    def _exec_tuple_assignment(self, node: ASTNode) -> Any:
+        """Execute tuple unpacking assignment: a, b, c = shuffled_func()
+
+        Used with shuffled functions that return multiple values.
+        """
+        targets = node.value.get('targets', [])
+        value = self._evaluate(node.value.get('value'))
+
+        # Convert value to list if it's a tuple or iterable
+        if isinstance(value, (list, tuple)):
+            values = list(value)
+        elif hasattr(value, '__iter__') and not isinstance(value, (str, dict)):
+            values = list(value)
+        else:
+            # Single value - assign to first target only
+            values = [value]
+
+        # Assign values to targets
+        for i, target in enumerate(targets):
+            if i < len(values):
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, values[i])
+            else:
+                # More targets than values - set to None
+                var_name = target.value if isinstance(target, ASTNode) else target
+                self.scope.set(var_name, None)
+
+        # Assignment statements don't produce a visible result
+        return None
+
     def _exec_expression(self, node: ASTNode) -> Any:
         """Execute expression statement"""
         return self._evaluate(node.value)

{includecpp-3.7.5 → includecpp-3.7.6}/includecpp/vscode/cssl/language-configuration.json

@@ -6,14 +6,12 @@
     "brackets": [
         ["{", "}"],
         ["[", "]"],
-        ["(", ")"],
-        ["<", ">"]
+        ["(", ")"]
     ],
     "autoClosingPairs": [
         { "open": "{", "close": "}" },
         { "open": "[", "close": "]" },
         { "open": "(", "close": ")" },
-        { "open": "<", "close": ">" },
         { "open": "\"", "close": "\"", "notIn": ["string"] },
         { "open": "'", "close": "'", "notIn": ["string", "comment"] }
     ],
@@ -21,7 +19,6 @@
         ["{", "}"],
         ["[", "]"],
         ["(", ")"],
-        ["<", ">"],
         ["\"", "\""],
         ["'", "'"]
     ],

{includecpp-3.7.5 → includecpp-3.7.6}/includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json

@@ -3,15 +3,18 @@
     "name": "CSSL",
     "scopeName": "source.cssl",
     "patterns": [
+        { "include": "#super-functions" },
         { "include": "#comments" },
         { "include": "#strings" },
         { "include": "#numbers" },
         { "include": "#class-definition" },
+        { "include": "#sql-types" },
         { "include": "#keywords" },
         { "include": "#types" },
         { "include": "#function-modifiers" },
         { "include": "#injection-operators" },
         { "include": "#namespace-functions" },
+        { "include": "#iterator-methods" },
         { "include": "#filter-helpers" },
         { "include": "#this-access" },
         { "include": "#captured-references" },
@@ -19,12 +22,26 @@
         { "include": "#shared-references" },
         { "include": "#instance-references" },
         { "include": "#module-references" },
+        { "include": "#reference-operator" },
+        { "include": "#method-calls" },
         { "include": "#function-calls" },
         { "include": "#builtins" },
         { "include": "#operators" },
         { "include": "#constants" }
     ],
     "repository": {
+        "super-functions": {
+            "patterns": [
+                {
+                    "name": "markup.bold.super.builtin.cssl",
+                    "match": "#\\$(run|exec|printl|init)\\b"
+                },
+                {
+                    "name": "markup.bold.super.call.cssl",
+                    "match": "#\\$[a-zA-Z_][a-zA-Z0-9_]*"
+                }
+            ]
+        },
         "comments": {
             "patterns": [
                 {
@@ -49,6 +66,10 @@
                             "name": "constant.character.escape.cssl",
                             "match": "\\\\."
                         },
+                        {
+                            "name": "variable.other.interpolated.fstring.cssl",
+                            "match": "\\{[a-zA-Z_][a-zA-Z0-9_]*\\}"
+                        },
                         {
                             "name": "variable.other.interpolated.cssl",
                             "match": "<[a-zA-Z_][a-zA-Z0-9_]*>"
@@ -118,6 +139,18 @@
                 }
             ]
         },
+        "sql-types": {
+            "patterns": [
+                {
+                    "name": "support.type.sql.table.cssl",
+                    "match": "\\bsql::table::(space|Section|limited|protected)\\b"
+                },
+                {
+                    "name": "support.type.sql.cssl",
+                    "match": "\\bsql::(table|data|data__list|sync|db)\\b"
+                }
+            ]
+        },
         "keywords": {
             "patterns": [
                 {
@@ -130,7 +163,7 @@
                 },
                 {
                     "name": "keyword.other.cssl",
-                    "match": "\\b(service-init|service-run|service-include|struct|structure|define|main|package|package-includes|exec|as|global|include|get|payload)\\b"
+                    "match": "\\b(service-init|service-run|service-include|struct|structure|define|main|package|package-includes|exec|as|global|include|get|payload|convert)\\b"
                 },
                 {
                     "name": "keyword.operator.logical.cssl",
@@ -146,18 +179,26 @@
             "patterns": [
                 {
                     "name": "storage.type.primitive.cssl",
-                    "match": "\\b(int|string|float|bool|void|json|dynamic)\\b"
+                    "match": "\\b(int|string|float|bool|void|json|dynamic|auto|long|double)\\b"
                 },
                 {
                     "name": "storage.type.container.cssl",
-                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance)\\b"
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance|tuple|set|queue)\\b"
                 },
                 {
                     "name": "storage.type.generic.cssl",
-                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance)\\s*<",
+                    "match": "\\b(array|vector|stack|list|dictionary|dict|map|datastruct|dataspace|shuffled|iterator|combo|openquote|instance|tuple|set|queue)\\s*<",
                     "captures": {
                         "1": { "name": "storage.type.container.cssl" }
                     }
+                },
+                {
+                    "name": "storage.type.map-literal.cssl",
+                    "match": "\\bmap\\s*<[^>]+>\\s*\\{"
+                },
+                {
+                    "name": "storage.type.combo-open.cssl",
+                    "match": "\\bcombo\\s*<\\s*open\\s*&"
                 }
             ]
         },
@@ -165,19 +206,27 @@
             "patterns": [
                 {
                     "name": "storage.modifier.cssl",
-                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased)\\b"
+                    "match": "\\b(undefined|open|closed|private|virtual|meta|super|sqlbased|protected|limited)\\b"
                 }
             ]
         },
         "injection-operators": {
             "patterns": [
                 {
-                    "name": "keyword.operator.injection.infuse.cssl",
-                    "match": "(\\+<<==|<<==|-<<==|==>>\\+|==>>|-==>>)"
+                    "name": "entity.name.tag.infuse.cssl",
+                    "match": "(\\+<<==|<<==|-<<==)"
+                },
+                {
+                    "name": "entity.name.tag.infuse.out.cssl",
+                    "match": "(==>>\\+|==>>|-==>>)"
                 },
                 {
                     "name": "keyword.operator.injection.brute.cssl",
-                    "match": "(\\+<==|<==|-<==|==>\\+|==>|-==>)"
+                    "match": "(\\+<==|<==|-<==)"
+                },
+                {
+                    "name": "keyword.operator.injection.brute.out.cssl",
+                    "match": "(==>\\+|==>|-==>)"
                 },
                 {
                     "name": "keyword.operator.flow.cssl",
@@ -189,7 +238,7 @@
             "patterns": [
                 {
                     "name": "support.function.namespace.json.cssl",
-                    "match": "\\bjson::(read|write|parse|stringify|pretty|get|set|has|keys|values|merge)\\b"
+                    "match": "\\bjson::(read|write|parse|stringify|pretty|get|set|has|keys|values|merge|key|value)\\b"
                 },
                 {
                     "name": "support.function.namespace.instance.cssl",
@@ -198,6 +247,26 @@
                 {
                     "name": "support.function.namespace.string.cssl",
                     "match": "\\bstring::(where|contains|not|startsWith|endsWith|length|lenght|cut|cutAfter|value)\\b"
+                },
+                {
+                    "name": "support.function.namespace.sql.cssl",
+                    "match": "\\bsql::(connect|load|save|update|sync|Structured)\\b"
+                },
+                {
+                    "name": "support.function.namespace.combo.cssl",
+                    "match": "\\bcombo::(filterdb|blocked|like)\\b"
+                }
+            ]
+        },
+        "iterator-methods": {
+            "patterns": [
+                {
+                    "name": "support.function.iterator.cssl",
+                    "match": "::iterator::(set|move|insert|pop|task|dtask|read|write)\\b"
+                },
+                {
+                    "name": "support.function.like.cssl",
+                    "match": "::like\\s*="
                 }
             ]
         },
@@ -205,7 +274,7 @@
             "patterns": [
                 {
                     "name": "support.function.filter.cssl",
-                    "match": "\\b(string|integer|json|array|vector|combo|dynamic|sql)::(where|contains|not|startsWith|endsWith|length|lenght|key|value|index|filterdb|blocked|data)\\b"
+                    "match": "\\[(string|integer|json|array|vector|combo|dynamic|sql)::(where|contains|not|startsWith|endsWith|length|lenght|key|value|index|filterdb|blocked|data)\\s*=?"
                 }
             ]
         },
@@ -269,6 +338,22 @@
                 }
             ]
         },
+        "reference-operator": {
+            "patterns": [
+                {
+                    "name": "keyword.operator.reference.cssl",
+                    "match": "&(?=[a-zA-Z_@])"
+                }
+            ]
+        },
+        "method-calls": {
+            "patterns": [
+                {
+                    "name": "support.function.method.cssl",
+                    "match": "\\.(push_back|append|insert|fill|at|is|read|write|content|save|where|load|update|oqt|connect|Structured|create|Queue|sync|pop|end|get|set|has|keys|values|convert)\\b"
+                }
+            ]
+        },
         "function-calls": {
             "patterns": [
                 {
@@ -293,7 +378,7 @@
                 },
                 {
                     "name": "support.function.builtin.special.cssl",
-                    "match": "\\b(OpenFind|share|shared)\\b"
+                    "match": "\\b(OpenFind|share|shared|include)\\b"
                 },
                 {
                     "name": "support.variable.builtin.parameter.cssl",

{includecpp-3.7.5 → includecpp-3.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "IncludeCPP"
-version = "3.7.5"
+version = "3.7.6"
 description = "Professional C++ Python bindings with type-generic templates, pystubs and native threading"
 readme = "README.md"
 requires-python = ">=3.9"