IncludeCPP 3.7.1__tar.gz → 3.7.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.1
+Version: 3.7.5
 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.1 → includecpp-3.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.1
+Version: 3.7.5
 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.1 → includecpp-3.7.5}/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.0"
+__version__ = "3.7.5"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

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

@@ -7535,10 +7535,29 @@ def cssl_makemodule(path, output):
 
 
 @cssl.command(name='doc')
-def cssl_doc():
-    """Show CSSL documentation."""
+@click.argument('search', required=False, default=None)
+@click.option('--list', '-l', 'list_sections', is_flag=True, help='List all documentation sections')
+def cssl_doc(search, list_sections):
+    """Show CSSL documentation.
+
+    \b
+    Usage:
+      includecpp cssl doc              # Show full documentation
+      includecpp cssl doc "open"       # Search for 'open' keyword
+      includecpp cssl doc "$"          # Search for shared variable syntax
+      includecpp cssl doc "define"     # Search for define keyword
+      includecpp cssl doc --list       # List all sections
+
+    \b
+    Examples:
+      includecpp cssl doc "class"      # Show OOP/class documentation
+      includecpp cssl doc "json::"     # Show JSON functions
+      includecpp cssl doc "this->"     # Show this-> keyword usage
+      includecpp cssl doc "map"        # Show Map container docs
+    """
     from pathlib import Path as PathLib
     import os
+    import re
 
     # Find the documentation file in the cssl package directory
     cssl_dir = PathLib(__file__).parent.parent / 'core' / 'cssl'
@@ -7558,8 +7577,96 @@ def cssl_doc():
 
     if doc_path.exists():
         content = doc_path.read_text(encoding='utf-8')
-        # Use pager for long content
-        click.echo_via_pager(content)
+
+        # List sections mode
+        if list_sections:
+            click.secho("CSSL Documentation Sections", fg='cyan', bold=True)
+            click.secho("=" * 40, fg='cyan')
+            sections = re.findall(r'^##\s+(.+)$', content, re.MULTILINE)
+            for i, section in enumerate(sections, 1):
+                click.echo(f"  {i:2d}. {section}")
+            click.echo()
+            click.echo("Use: includecpp cssl doc \"<keyword>\" to search")
+            return
+
+        # Search mode
+        if search:
+            click.secho(f"Searching for: '{search}'", fg='cyan', bold=True)
+            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)}")
+
+                click.echo()
+
+                # Show matching contexts with highlighting
+                click.secho("Matching content:", fg='yellow', bold=True)
+                click.secho("-" * 50, fg='yellow')
+
+                for line_num, context in matching_lines[:15]:  # Limit to 15 matches
+                    click.echo(f"\nLine {line_num}:")
+                    # Highlight the search term
+                    highlighted = re.sub(
+                        f'({re.escape(search)})',
+                        click.style(r'\1', fg='green', bold=True),
+                        context,
+                        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)
+                    click.echo()
+
+            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")
+        else:
+            # Full documentation mode
+            click.echo_via_pager(content)
     else:
         click.secho("Documentation file not found.", fg='yellow')
         click.echo("Looking for: CSSL_DOCUMENTATION.md")

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

@@ -1,6 +1,6 @@
 # CSSL - C-Style Scripting Language
 
-> Version 3.7.0 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
+> Version 3.7.2 | A modern scripting language with C++-style syntax and unique features like CodeInfusion and BruteInjection.
 
 ---
 

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

@@ -108,6 +108,8 @@ class TokenType(Enum):
     COMMENT = auto()
     NEWLINE = auto()
     EOF = auto()
+    # Super-functions for .cssl-pl payload files (v3.8.0)
+    SUPER_FUNC = auto()    # #$run(), #$exec(), #$printl() - pre-execution hooks
 
 
 KEYWORDS = {
@@ -212,9 +214,14 @@ class CSSLLexer:
 
             char = self.source[self.pos]
 
-            # Comments: both # and // style
+            # Super-functions (#$) or Comments (# and // style)
             if char == '#':
-                self._skip_comment()
+                if self._peek(1) == '$':
+                    # Super-function: #$run(), #$exec(), #$printl()
+                    self._read_super_function()
+                else:
+                    # Regular comment
+                    self._skip_comment()
             elif char == '/' and self._peek(1) == '/':
                 # C-style // comment - NEW
                 self._skip_comment()
@@ -446,6 +453,31 @@ class CSSLLexer:
         else:
             self._add_token(TokenType.IDENTIFIER, value)
 
+    def _read_super_function(self):
+        """Read #$<name>(...) super-function call for .cssl-pl payloads.
+
+        Super-functions are pre-execution hooks that run when a payload is loaded.
+        Valid super-functions: #$run(), #$exec(), #$printl()
+
+        Syntax:
+            #$run(initFunction);        // Call a function at load time
+            #$exec(setup());            // Execute expression at load time
+            #$printl("Payload loaded"); // Print at load time
+        """
+        start = self.pos
+        self._advance()  # skip '#'
+        self._advance()  # skip '$'
+
+        # Read the super-function name (run, exec, printl, etc.)
+        name_start = self.pos
+        while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+            self._advance()
+        func_name = self.source[name_start:self.pos]
+
+        # Store as #$<name> token value
+        value = f'#${func_name}'
+        self._add_token(TokenType.SUPER_FUNC, value)
+
     def _read_self_ref(self):
         """Read s@<name> or s@<name>.<member>... self-reference"""
         start = self.pos
@@ -1377,6 +1409,9 @@ class CSSLParser:
         elif self._looks_like_function_declaration():
             # Nested typed function (e.g., void Level2() { ... })
             return self._parse_typed_function()
+        elif self._check(TokenType.SUPER_FUNC):
+            # Super-function for .cssl-pl payload files
+            return self._parse_super_function()
         elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
               self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
               self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
@@ -1594,23 +1629,42 @@ class CSSLParser:
         return ASTNode('c_for_update', value={'var': var_name, 'op': 'none'})
 
     def _parse_python_style_for(self) -> ASTNode:
-        """Parse Python-style for loop: for (i in range(...)) { }
+        """Parse Python-style for loop: for (i in range(...)) { } or for (item in collection) { }
 
         Supports:
             for (i in range(n)) { }           - 0 to n-1
             for (i in range(start, end)) { }  - start to end-1
             for (i in range(start, end, step)) { }
+            for (item in collection) { }      - iterate over list/vector
+            for (item in @global_collection) { } - iterate over global
         """
         var_name = self._advance().value
         self._expect(TokenType.KEYWORD)  # 'in'
 
-        # 'range' can be keyword or identifier
+        # Check if this is range() or collection iteration
+        is_range = False
         if self._check(TokenType.KEYWORD) and self._peek().value == 'range':
             self._advance()  # consume 'range' keyword
+            is_range = True
         elif self._check(TokenType.IDENTIFIER) and self._peek().value == 'range':
             self._advance()  # consume 'range' identifier
-        else:
-            self.error(f"Expected 'range', got {self._peek().value}")
+            is_range = True
+
+        # If not range, parse as collection iteration
+        if not is_range:
+            iterable = self._parse_expression()
+            self._expect(TokenType.PAREN_END)
+
+            node = ASTNode('foreach', value={'var': var_name, 'iterable': iterable}, children=[])
+            self._expect(TokenType.BLOCK_START)
+
+            while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                stmt = self._parse_statement()
+                if stmt:
+                    node.children.append(stmt)
+
+            self._expect(TokenType.BLOCK_END)
+            return node
 
         self._expect(TokenType.PAREN_START)
         first_arg = self._parse_expression()
@@ -1728,6 +1782,31 @@ class CSSLParser:
         self._match(TokenType.SEMICOLON)
         return ASTNode('return', value=value)
 
+    def _parse_super_function(self) -> ASTNode:
+        """Parse super-function for .cssl-pl payload files.
+
+        Syntax:
+            #$run(initFunction);           // Call function at load time
+            #$exec(setup());               // Execute expression at load time
+            #$printl("Payload loaded");    // Print at load time
+
+        These are pre-execution hooks that run when payload() loads the file.
+        """
+        token = self._advance()  # Get the SUPER_FUNC token
+        super_name = token.value  # e.g., "#$run", "#$exec", "#$printl"
+
+        # Parse the arguments
+        self._expect(TokenType.PAREN_START)
+        args = []
+        if not self._check(TokenType.PAREN_END):
+            args.append(self._parse_expression())
+            while self._match(TokenType.COMMA):
+                args.append(self._parse_expression())
+        self._expect(TokenType.PAREN_END)
+        self._match(TokenType.SEMICOLON)
+
+        return ASTNode('super_func', value={'name': super_name, 'args': args})
+
     def _parse_try(self) -> ASTNode:
         node = ASTNode('try', children=[])
 
@@ -2335,17 +2414,62 @@ class CSSLParser:
             self._expect(TokenType.COMPARE_GT)  # consume >
             return ASTNode('instance_ref', value=instance_name)
 
-        # Check for type generic instantiation: stack<string>, vector<int>, etc.
+        # Check for type generic instantiation: stack<string>, vector<int>, map<string, int>, etc.
         # This creates a new instance of the type with the specified element type
         if name in TYPE_GENERICS and self._check(TokenType.COMPARE_LT):
             self._advance()  # consume <
             element_type = 'dynamic'
+            value_type = None  # For map<K, V>
+
             if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
                 element_type = self._advance().value
+
+            # Check for second type parameter (map<K, V>)
+            if name == 'map' and self._check(TokenType.COMMA):
+                self._advance()  # consume ,
+                if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+                    value_type = self._advance().value
+                else:
+                    value_type = 'dynamic'
+
             self._expect(TokenType.COMPARE_GT)  # consume >
+
+            # Check for inline initialization: map<K,V>{"key": "value", ...}
+            init_values = None
+            if self._check(TokenType.BLOCK_START):
+                self._advance()  # consume {
+                init_values = {}
+
+                while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                    # Parse key
+                    if self._check(TokenType.STRING):
+                        key = self._advance().value
+                    elif self._check(TokenType.IDENTIFIER):
+                        key = self._advance().value
+                    else:
+                        key = str(self._parse_expression().value) if hasattr(self._parse_expression(), 'value') else 'key'
+
+                    # Expect : or =
+                    if self._check(TokenType.COLON):
+                        self._advance()
+                    elif self._check(TokenType.EQUALS):
+                        self._advance()
+
+                    # Parse value
+                    value = self._parse_expression()
+                    init_values[key] = value
+
+                    # Optional comma
+                    if self._check(TokenType.COMMA):
+                        self._advance()
+
+                self._expect(TokenType.BLOCK_END)  # consume }
+
             return ASTNode('type_instantiation', value={
                 'type': name,
-                'element_type': element_type
+                'element_type': element_type,
+                'value_type': value_type,
+                'init_values': init_values
             })
 
         # Check for type-parameterized function call: OpenFind<string>(0)

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

@@ -401,6 +401,9 @@ class CSSLRuntime:
             elif child.type == 'instance_declaration':
                 # Handle instance declaration: instance<"name"> varName;
                 result = self._exec_instance_declaration(child)
+            elif child.type == 'super_func':
+                # Super-function for .cssl-pl payload files (#$run, #$exec, #$printl)
+                result = self._exec_super_func(child)
             elif child.type in ('assignment', 'expression', 'inject', 'receive', 'flow',
                                'if', 'while', 'for', 'c_for', 'foreach', 'switch', 'try'):
                 result = self._execute_node(child)
@@ -820,6 +823,82 @@ class CSSLRuntime:
         self.scope.set(var_name, instance)
         return instance
 
+    def _exec_super_func(self, node: ASTNode) -> Any:
+        """Execute super-function for .cssl-pl payload files.
+
+        Super-functions are pre-execution hooks that run when payload() loads a file.
+
+        Supported super-functions:
+            #$run(funcName)        - Call a function defined in the payload
+            #$exec(expression)     - Execute an expression immediately
+            #$printl(message)      - Print a message during load
+
+        Example .cssl-pl file:
+            void initDatabase() {
+                printl("DB initialized");
+            }
+
+            #$run(initDatabase);       // Calls initDatabase when payload loads
+            #$printl("Payload loaded"); // Prints during load
+        """
+        super_info = node.value
+        super_name = super_info.get('name', '')  # e.g., "#$run", "#$exec", "#$printl"
+        args = super_info.get('args', [])
+
+        # Extract the function name part (after #$)
+        if super_name.startswith('#$'):
+            func_type = super_name[2:]  # "run", "exec", "printl"
+        else:
+            func_type = super_name
+
+        if func_type == 'run':
+            # #$run(funcName) - Call a function by name
+            if args:
+                func_ref = args[0]
+                if isinstance(func_ref, ASTNode):
+                    if func_ref.type == 'identifier':
+                        func_name = func_ref.value
+                    elif func_ref.type == 'call':
+                        # Direct call like #$run(setup())
+                        return self._eval_call(func_ref)
+                    else:
+                        func_name = self._evaluate(func_ref)
+                else:
+                    func_name = str(func_ref)
+
+                # Look up and call the function
+                func_node = self.scope.get(func_name)
+                if func_node and isinstance(func_node, ASTNode) and func_node.type == 'function':
+                    return self._call_function(func_node, [])
+                else:
+                    raise CSSLRuntimeError(f"#$run: Function '{func_name}' not found", node.line)
+
+        elif func_type == 'exec':
+            # #$exec(expression) - Execute an expression
+            if args:
+                return self._evaluate(args[0])
+
+        elif func_type == 'printl':
+            # #$printl(message) - Print a message
+            if args:
+                msg = self._evaluate(args[0])
+                print(str(msg))
+                self.output_buffer.append(str(msg))
+                return None
+
+        elif func_type == 'print':
+            # #$print(message) - Print without newline
+            if args:
+                msg = self._evaluate(args[0])
+                print(str(msg), end='')
+                self.output_buffer.append(str(msg))
+                return None
+
+        else:
+            raise CSSLRuntimeError(f"Unknown super-function: {super_name}", node.line)
+
+        return None
+
     def _exec_global_assignment(self, node: ASTNode) -> Any:
         """Execute global variable assignment: global Name = value
 
@@ -884,10 +963,20 @@ class CSSLRuntime:
 
         # Bind parameters - handle both positional and named arguments
         for i, param in enumerate(params):
-            # Extract param name from dict format: {'name': 'a', 'type': 'int'}
-            param_name = param['name'] if isinstance(param, dict) else param
-
-            if param_name in kwargs:
+            # Extract param name and type from dict format: {'name': 'a', 'type': 'int'}
+            if isinstance(param, dict):
+                param_name = param['name']
+                param_type = param.get('type', '')
+            else:
+                param_name = param
+                param_type = ''
+
+            # Check if this is an 'open' parameter - receives all args as a list
+            if param_type == 'open' or param_name == 'Params':
+                # 'open Params' receives all arguments as a list
+                new_scope.set(param_name, list(args))
+                new_scope.set('Params', list(args))  # Also set 'Params' for OpenFind
+            elif param_name in kwargs:
                 # Named argument takes priority
                 new_scope.set(param_name, kwargs[param_name])
             elif i < len(args):
@@ -1778,9 +1867,12 @@ class CSSLRuntime:
 
         if node.type == 'literal':
             value = node.value
-            # NEW: String interpolation - replace <variable> with scope values
-            if isinstance(value, str) and '<' in value and '>' in value:
-                value = self._interpolate_string(value)
+            # String interpolation - replace {var} or <var> with scope values
+            if isinstance(value, str):
+                has_fstring = '{' in value and '}' in value
+                has_legacy = '<' in value and '>' in value
+                if has_fstring or has_legacy:
+                    value = self._interpolate_string(value)
             return value
 
         # NEW: Type literals (list, dict) - create empty instances
@@ -1890,9 +1982,11 @@ class CSSLRuntime:
             return self._eval_this_access(node)
 
         if node.type == 'type_instantiation':
-            # Create new instance of a type: stack<string>, vector<int>, etc.
+            # Create new instance of a type: stack<string>, vector<int>, map<K,V>, etc.
             type_name = node.value.get('type')
             element_type = node.value.get('element_type', 'dynamic')
+            value_type = node.value.get('value_type')  # For map<K, V>
+            init_values = node.value.get('init_values')  # For inline init: map<K,V>{...}
 
             if type_name == 'stack':
                 return Stack(element_type)
@@ -1916,6 +2010,15 @@ class CSSLRuntime:
                 return List(element_type)
             elif type_name in ('dictionary', 'dict'):
                 return Dictionary(element_type)
+            elif type_name == 'map':
+                # Create Map with key_type and value_type
+                m = Map(element_type, value_type or 'dynamic')
+                # If inline initialization provided, populate the map
+                if init_values:
+                    for key, value_node in init_values.items():
+                        value = self._evaluate(value_node)
+                        m.insert(key, value)
+                return m
             else:
                 return None
 
@@ -2714,14 +2817,24 @@ class CSSLRuntime:
         elif isinstance(obj, dict):
             obj[final_attr] = value
 
-    # NEW: String interpolation
+    # String interpolation (supports both <var> and {var} syntax)
     def _interpolate_string(self, string: str) -> str:
-        """Replace <variable> placeholders with values from scope - NEW
+        """Replace {variable} and <variable> placeholders with values from scope.
+
+        Both syntaxes are supported (variables only, not expressions):
+            "Hello {name}!"   -> "Hello John!"  (f-string style)
+            "Hello <name>!"   -> "Hello John!"  (legacy CSSL style)
+
+        Examples:
+            string name = "Alice";
+            int age = 30;
+            printl("Hello {name}, you are {age} years old!");
+            printl("Hello <name>, you are <age> years old!");
 
-        Example: "Hello <name>!" becomes "Hello John!" if name = "John"
+        Note: Only simple variable names are supported, not expressions.
+        Use string concatenation for complex expressions.
         """
         import re
-        pattern = r'<([A-Za-z_][A-Za-z0-9_]*)>'
 
         def replacer(match):
             var_name = match.group(1)
@@ -2733,10 +2846,23 @@ class CSSLRuntime:
             # Try modules
             if value is None:
                 value = self._modules.get(var_name)
+            # Try global scope
+            if value is None:
+                value = self.global_scope.get(var_name)
             # Return string representation or empty string if None
             return str(value) if value is not None else ''
 
-        return re.sub(pattern, replacer, string)
+        # Support both {var} and <var> syntax - simple variable names only
+        # Pattern: {identifier} or <identifier>
+        patterns = [
+            r'\{([A-Za-z_][A-Za-z0-9_]*)\}',  # {name} f-string style
+            r'<([A-Za-z_][A-Za-z0-9_]*)>',     # <name> legacy CSSL style
+        ]
+
+        result = string
+        for pattern in patterns:
+            result = re.sub(pattern, replacer, result)
+        return result
 
     # NEW: Promote variable to global scope via global()
     def promote_to_global(self, s_ref_name: str):