IncludeCPP 3.4.2__py3-none-any.whl → 3.4.8__py3-none-any.whl

includecpp/__init__.py

@@ -1,59 +1,59 @@
-from .core.cpp_api import CppApi
-from .core import cssl_bridge as CSSL
-import warnings
-
-__version__ = "3.4.2"
-__all__ = ["CppApi", "CSSL"]
-
-# Module-level cache for C++ modules
-_api_instance = None
-_loaded_modules = {}
-
-def _get_api():
-    """Get or create singleton CppApi instance."""
-    global _api_instance
-    if _api_instance is None:
-        _api_instance = CppApi()
-    return _api_instance
-
-def __getattr__(name: str):
-    """Enable: from includecpp import fast_list
-
-    This hook is called when Python cannot find an attribute in this module.
-    It allows dynamic C++ module loading via the import system.
-    """
-    if name.startswith('_'):
-        raise AttributeError(f"module 'includecpp' has no attribute '{name}'")
-
-    if name in _loaded_modules:
-        return _loaded_modules[name]
-
-    api = _get_api()
-
-    if name not in api.registry:
-        available = list(api.registry.keys())
-        raise AttributeError(
-            f"Module '{name}' not found. "
-            f"Available: {available}. "
-            f"Run 'includecpp rebuild' first."
-        )
-
-    if api.need_update(name):
-        warnings.warn(
-            f"Module '{name}' source files changed. "
-            f"Run 'includecpp rebuild' to update.",
-            UserWarning
-        )
-
-    module = api.include(name)
-    _loaded_modules[name] = module
-    return module
-
-def __dir__():
-    """List available attributes including C++ modules."""
-    base = ['CppApi', 'CSSL', '__version__']
-    try:
-        api = _get_api()
-        return sorted(set(base + list(api.registry.keys())))
-    except Exception:
-        return base
+from .core.cpp_api import CppApi
+from .core import cssl_bridge as CSSL
+import warnings
+
+__version__ = "3.4.8"
+__all__ = ["CppApi", "CSSL"]
+
+# Module-level cache for C++ modules
+_api_instance = None
+_loaded_modules = {}
+
+def _get_api():
+    """Get or create singleton CppApi instance."""
+    global _api_instance
+    if _api_instance is None:
+        _api_instance = CppApi()
+    return _api_instance
+
+def __getattr__(name: str):
+    """Enable: from includecpp import fast_list
+
+    This hook is called when Python cannot find an attribute in this module.
+    It allows dynamic C++ module loading via the import system.
+    """
+    if name.startswith('_'):
+        raise AttributeError(f"module 'includecpp' has no attribute '{name}'")
+
+    if name in _loaded_modules:
+        return _loaded_modules[name]
+
+    api = _get_api()
+
+    if name not in api.registry:
+        available = list(api.registry.keys())
+        raise AttributeError(
+            f"Module '{name}' not found. "
+            f"Available: {available}. "
+            f"Run 'includecpp rebuild' first."
+        )
+
+    if api.need_update(name):
+        warnings.warn(
+            f"Module '{name}' source files changed. "
+            f"Run 'includecpp rebuild' to update.",
+            UserWarning
+        )
+
+    module = api.include(name)
+    _loaded_modules[name] = module
+    return module
+
+def __dir__():
+    """List available attributes including C++ modules."""
+    base = ['CppApi', 'CSSL', '__version__']
+    try:
+        api = _get_api()
+        return sorted(set(base + list(api.registry.keys())))
+    except Exception:
+        return base

includecpp/core/cssl/__init__.py

@@ -19,9 +19,9 @@ from .cssl_parser import (
 from .cssl_runtime import CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file
 from .cssl_types import (
     DataStruct, Shuffled, Iterator, Combo, DataSpace, OpenQuote,
-    OpenFind,
+    OpenFind, Parameter,
     create_datastruct, create_shuffled, create_iterator,
-    create_combo, create_dataspace, create_openquote
+    create_combo, create_dataspace, create_openquote, create_parameter
 )
 
 __all__ = [
@@ -34,7 +34,7 @@ __all__ = [
     'run_cssl', 'run_cssl_file',
     # Data Types
     'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
-    'OpenFind',
+    'OpenFind', 'Parameter',
     'create_datastruct', 'create_shuffled', 'create_iterator',
-    'create_combo', 'create_dataspace', 'create_openquote'
+    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter'
 ]

includecpp/core/cssl/cssl_parser.py

@@ -216,6 +216,9 @@ class CSSLLexer:
                 self.column = 1
             elif char in '"\'':
                 self._read_string(char)
+            elif char == '`':
+                # Raw string (no escape processing) - useful for JSON
+                self._read_raw_string()
             elif char.isdigit() or (char == '-' and self._peek(1).isdigit()):
                 self._read_number()
             elif char == 'r' and self._peek(1) == '@':
@@ -224,7 +227,7 @@ class CSSLLexer:
             elif char == 's' and self._peek(1) == '@':
                 # s@<name> self-reference to global struct
                 self._read_self_ref()
-            elif char.isalpha() or char == '_' or char == '-':
+            elif char.isalpha() or char == '_':
                 self._read_identifier()
             elif char == '@':
                 self._add_token(TokenType.AT, '@')
@@ -346,13 +349,52 @@ class CSSLLexer:
     def _read_string(self, quote_char: str):
         self._advance()
         start = self.pos
+        result = []
         while self.pos < len(self.source) and self.source[self.pos] != quote_char:
-            if self.source[self.pos] == '\\':
+            if self.source[self.pos] == '\\' and self.pos + 1 < len(self.source):
+                # Handle escape sequences
+                next_char = self.source[self.pos + 1]
+                if next_char == 'n':
+                    result.append('\n')
+                elif next_char == 't':
+                    result.append('\t')
+                elif next_char == 'r':
+                    result.append('\r')
+                elif next_char == '\\':
+                    result.append('\\')
+                elif next_char == quote_char:
+                    result.append(quote_char)
+                elif next_char == '"':
+                    result.append('"')
+                elif next_char == "'":
+                    result.append("'")
+                else:
+                    result.append(self.source[self.pos])
+                    result.append(next_char)
+                self._advance()
+                self._advance()
+            else:
+                result.append(self.source[self.pos])
                 self._advance()
+        value = ''.join(result)
+        self._add_token(TokenType.STRING, value)
+        self._advance()
+
+    def _read_raw_string(self):
+        """Read raw string with backticks - no escape processing.
+
+        Useful for JSON: `{"id": "2819e1", "name": "test"}`
+        """
+        self._advance()  # Skip opening backtick
+        start = self.pos
+        while self.pos < len(self.source) and self.source[self.pos] != '`':
+            if self.source[self.pos] == '\n':
+                self.line += 1
+                self.column = 0
             self._advance()
         value = self.source[start:self.pos]
         self._add_token(TokenType.STRING, value)
-        self._advance()
+        self._advance()  # Skip closing backtick
 
     def _read_number(self):
         start = self.pos
@@ -368,7 +410,7 @@ class CSSLLexer:
 
     def _read_identifier(self):
         start = self.pos
-        while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] in '_-'):
+        while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
             self._advance()
         value = self.source[start:self.pos]
 
@@ -588,6 +630,176 @@ class CSSLParser:
         self._match(TokenType.BLOCK_END)
         return root
 
+    def _is_function_modifier(self, value: str) -> bool:
+        """Check if a keyword is a function modifier"""
+        return value in ('undefined', 'open', 'meta', 'super', 'closed', 'private', 'virtual', 'sqlbased')
+
+    def _is_type_keyword(self, value: str) -> bool:
+        """Check if a keyword is a type declaration"""
+        return value in ('int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
+                        'dynamic', 'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo', 'structure')
+
+    def _looks_like_function_declaration(self) -> bool:
+        """Check if current position looks like a C-style function declaration.
+
+        Patterns:
+        - int funcName(...)
+        - undefined int funcName(...)
+        - vector<string> funcName(...)
+        - undefined void funcName(...)
+        """
+        saved_pos = self.pos
+
+        # Skip modifiers (undefined, open, meta, super, closed, private, virtual)
+        while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
+            self._advance()
+
+        # Check for type keyword
+        if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
+            self._advance()
+
+            # Skip generic type parameters <T>
+            if self._check(TokenType.COMPARE_LT):
+                depth = 1
+                self._advance()
+                while depth > 0 and not self._is_at_end():
+                    if self._check(TokenType.COMPARE_LT):
+                        depth += 1
+                    elif self._check(TokenType.COMPARE_GT):
+                        depth -= 1
+                    self._advance()
+
+            # Check for identifier followed by (
+            if self._check(TokenType.IDENTIFIER):
+                self._advance()
+                is_func = self._check(TokenType.PAREN_START)
+                self.pos = saved_pos
+                return is_func
+
+        self.pos = saved_pos
+        return False
+
+    def _parse_typed_function(self) -> ASTNode:
+        """Parse C-style typed function declaration.
+
+        Patterns:
+        - int Add(int a, int b) { }
+        - undefined int Func() { }
+        - open void Handler(open Params) { }
+        - vector<string> GetNames() { }
+        """
+        modifiers = []
+        return_type = None
+        generic_type = None
+
+        # Collect modifiers (undefined, open, meta, super, closed, private, virtual)
+        while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
+            modifiers.append(self._advance().value)
+
+        # Get return type
+        if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
+            return_type = self._advance().value
+
+            # Check for generic type <T>
+            if self._check(TokenType.COMPARE_LT):
+                self._advance()  # skip <
+                generic_parts = []
+                depth = 1
+                while depth > 0 and not self._is_at_end():
+                    if self._check(TokenType.COMPARE_LT):
+                        depth += 1
+                        generic_parts.append('<')
+                    elif self._check(TokenType.COMPARE_GT):
+                        depth -= 1
+                        if depth > 0:
+                            generic_parts.append('>')
+                    elif self._check(TokenType.COMMA):
+                        generic_parts.append(',')
+                    else:
+                        generic_parts.append(self._current().value)
+                    self._advance()
+                generic_type = ''.join(generic_parts)
+
+        # Get function name
+        name = self._advance().value
+
+        # Parse parameters
+        params = []
+        self._expect(TokenType.PAREN_START)
+
+        while not self._check(TokenType.PAREN_END) and not self._is_at_end():
+            param_info = {}
+
+            # Handle 'open' keyword for open parameters
+            if self._match_keyword('open'):
+                param_info['open'] = True
+
+            # Handle type annotations
+            if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
+                param_info['type'] = self._advance().value
+
+                # Check for generic type parameter <T>
+                if self._check(TokenType.COMPARE_LT):
+                    self._advance()
+                    generic_parts = []
+                    depth = 1
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                            generic_parts.append('<')
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                            if depth > 0:
+                                generic_parts.append('>')
+                        elif self._check(TokenType.COMMA):
+                            generic_parts.append(',')
+                        else:
+                            generic_parts.append(self._current().value)
+                        self._advance()
+                    param_info['generic'] = ''.join(generic_parts)
+
+            # Handle reference operator &
+            if self._match(TokenType.AMPERSAND):
+                param_info['ref'] = True
+
+            # Get parameter name
+            if self._check(TokenType.IDENTIFIER):
+                param_name = self._advance().value
+                if param_info:
+                    params.append({'name': param_name, **param_info})
+                else:
+                    params.append(param_name)
+            elif self._check(TokenType.KEYWORD):
+                # Parameter name could be a keyword
+                param_name = self._advance().value
+                if param_info:
+                    params.append({'name': param_name, **param_info})
+                else:
+                    params.append(param_name)
+
+            self._match(TokenType.COMMA)
+
+        self._expect(TokenType.PAREN_END)
+
+        # Parse function body
+        node = ASTNode('function', value={
+            'name': name,
+            'params': params,
+            'return_type': return_type,
+            'generic_type': generic_type,
+            'modifiers': modifiers
+        }, 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
+
     def parse_program(self) -> ASTNode:
         """Parse a standalone program (no service wrapper)"""
         root = ASTNode('program', children=[])
@@ -597,6 +809,30 @@ class CSSLParser:
                 root.children.append(self._parse_struct())
             elif self._match_keyword('define'):
                 root.children.append(self._parse_define())
+            # Check for C-style typed function declarations
+            elif self._looks_like_function_declaration():
+                root.children.append(self._parse_typed_function())
+            # Handle service blocks
+            elif self._match_keyword('service-init'):
+                root.children.append(self._parse_service_init())
+            elif self._match_keyword('service-include'):
+                root.children.append(self._parse_service_include())
+            elif self._match_keyword('service-run'):
+                root.children.append(self._parse_service_run())
+            elif self._match_keyword('package'):
+                root.children.append(self._parse_package())
+            elif self._match_keyword('package-includes'):
+                root.children.append(self._parse_package_includes())
+            # Handle global declarations
+            elif self._match_keyword('global'):
+                stmt = self._parse_expression_statement()
+                if stmt:
+                    root.children.append(stmt)
+            elif self._check(TokenType.GLOBAL_REF):
+                stmt = self._parse_expression_statement()
+                if stmt:
+                    root.children.append(stmt)
+            # Handle statements
             elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or self._check(TokenType.SELF_REF):
                 stmt = self._parse_expression_statement()
                 if stmt:
@@ -609,6 +845,9 @@ class CSSLParser:
                 root.children.append(self._parse_for())
             elif self._match_keyword('foreach'):
                 root.children.append(self._parse_foreach())
+            # Skip comments and newlines
+            elif self._check(TokenType.COMMENT) or self._check(TokenType.NEWLINE):
+                self._advance()
             else:
                 self._advance()
 
@@ -837,8 +1076,31 @@ class CSSLParser:
 
         if self._match(TokenType.PAREN_START):
             while not self._check(TokenType.PAREN_END):
+                param_info = {}
+                # Handle 'open' keyword for open parameters
+                if self._match_keyword('open'):
+                    param_info['open'] = True
+                # Handle type annotations (e.g., string, int, dynamic, etc.)
+                if self._check(TokenType.KEYWORD):
+                    param_info['type'] = self._advance().value
+                # Handle reference operator &
+                if self._match(TokenType.AMPERSAND):
+                    param_info['ref'] = True
+                # Get parameter name
                 if self._check(TokenType.IDENTIFIER):
-                    params.append(self._advance().value)
+                    param_name = self._advance().value
+                    if param_info:
+                        params.append({'name': param_name, **param_info})
+                    else:
+                        params.append(param_name)
+                    self._match(TokenType.COMMA)
+                elif self._check(TokenType.KEYWORD):
+                    # Parameter name could be a keyword like 'Params'
+                    param_name = self._advance().value
+                    if param_info:
+                        params.append({'name': param_name, **param_info})
+                    else:
+                        params.append(param_name)
                     self._match(TokenType.COMMA)
                 else:
                     break
@@ -878,6 +1140,12 @@ class CSSLParser:
             return self._parse_try()
         elif self._match_keyword('await'):
             return self._parse_await()
+        elif self._match_keyword('define'):
+            # Nested define function
+            return self._parse_define()
+        elif self._looks_like_function_declaration():
+            # Nested typed function (e.g., void Level2() { ... })
+            return self._parse_typed_function()
         elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT):
             return self._parse_expression_statement()
         else:
@@ -1077,6 +1345,9 @@ class CSSLParser:
             # Check for define statements inside action block
             if self._match_keyword('define'):
                 node.children.append(self._parse_define())
+            # Check for typed function definitions (nested functions)
+            elif self._looks_like_function_declaration():
+                node.children.append(self._parse_typed_function())
             else:
                 stmt = self._parse_statement()
                 if stmt:
@@ -1320,12 +1591,39 @@ class CSSLParser:
         if self._match(TokenType.MINUS):
             operand = self._parse_unary()
             return ASTNode('unary', value={'op': '-', 'operand': operand})
+        if self._match(TokenType.AMPERSAND):
+            # Reference operator: &variable or &@module
+            operand = self._parse_unary()
+            return ASTNode('reference', value=operand)
 
         return self._parse_primary()
 
     def _parse_primary(self) -> ASTNode:
         if self._match(TokenType.AT):
-            return self._parse_module_reference()
+            node = self._parse_module_reference()
+            # Continue to check for calls, indexing, member access on module refs
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    # Function call on module ref: @Module.method()
+                    args = []
+                    while not self._check(TokenType.PAREN_END) and not self._is_at_end():
+                        args.append(self._parse_expression())
+                        if not self._check(TokenType.PAREN_END):
+                            self._expect(TokenType.COMMA)
+                    self._expect(TokenType.PAREN_END)
+                    node = ASTNode('call', value={'callee': node, 'args': args})
+                elif self._match(TokenType.DOT):
+                    # Member access: @Module.property
+                    member = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                elif self._match(TokenType.BRACKET_START):
+                    # Index access: @Module[index]
+                    index = self._parse_expression()
+                    self._expect(TokenType.BRACKET_END)
+                    node = ASTNode('index_access', value={'object': node, 'index': index})
+                else:
+                    break
+            return node
 
         if self._check(TokenType.SELF_REF):
             # s@<name> self-reference to global struct

includecpp/core/cssl/cssl_runtime.py

@@ -12,6 +12,7 @@ from .cssl_parser import ASTNode, parse_cssl, parse_cssl_program, CSSLSyntaxErro
 from .cssl_events import CSSLEventManager, EventType, EventData, get_event_manager
 from .cssl_builtins import CSSLBuiltins
 from .cssl_modules import get_module_registry, get_standard_module
+from .cssl_types import Parameter, DataStruct, Shuffled, Iterator, Combo
 
 
 class CSSLRuntimeError(Exception):
@@ -567,16 +568,22 @@ class CSSLRuntime:
         """Call a function node with arguments"""
         func_info = func_node.value
         params = func_info.get('params', [])
+        modifiers = func_info.get('modifiers', [])
+
+        # Check for undefined modifier - suppress errors if present
+        is_undefined = 'undefined' in modifiers
 
         # Create new scope
         new_scope = Scope(parent=self.scope)
 
-        # Bind parameters
+        # Bind parameters - handle both string and dict formats
         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 i < len(args):
-                new_scope.set(param, args[i])
+                new_scope.set(param_name, args[i])
             else:
-                new_scope.set(param, None)
+                new_scope.set(param_name, None)
 
         # Execute body
         old_scope = self.scope
@@ -587,6 +594,11 @@ class CSSLRuntime:
                 self._execute_node(child)
         except CSSLReturn as ret:
             return ret.value
+        except Exception as e:
+            # If undefined modifier, suppress all errors
+            if is_undefined:
+                return None
+            raise
         finally:
             self.scope = old_scope
 
@@ -881,7 +893,11 @@ class CSSLRuntime:
         # Get current target value for add/move modes
         current_value = None
         if mode in ('add', 'move'):
-            current_value = self._evaluate(target)
+            try:
+                current_value = self._evaluate(target)
+            except Exception:
+                # Target might not exist yet, that's okay for add mode
+                current_value = None
 
         # Determine final value based on mode
         if mode == 'replace':
@@ -1188,6 +1204,17 @@ class CSSLRuntime:
         if node.type == 'object':
             return {k: self._evaluate(v) for k, v in node.value.items()}
 
+        if node.type == 'reference':
+            # &variable - return a reference object wrapping the actual value
+            inner = node.value
+            if isinstance(inner, ASTNode):
+                if inner.type == 'identifier':
+                    # Return a reference wrapper with the variable name
+                    return {'__ref__': True, 'name': inner.value, 'value': self.scope.get(inner.value)}
+                elif inner.type == 'module_ref':
+                    return {'__ref__': True, 'name': inner.value, 'value': self.get_module(inner.value)}
+            return {'__ref__': True, 'value': self._evaluate(inner)}
+
         return None
 
     def _eval_binary(self, node: ASTNode) -> Any:
@@ -1388,15 +1415,26 @@ class CSSLRuntime:
 
     # NEW: Execute injected code for a function
     def _execute_function_injections(self, func_name: str):
-        """Execute all injected code blocks for a function - NEW"""
+        """Execute all injected code blocks for a function - NEW
+
+        Includes protection against recursive execution to prevent doubled output.
+        """
+        # Prevent recursive injection execution (fixes doubled output bug)
+        if getattr(self, '_injection_executing', False):
+            return
+
         if func_name in self._function_injections:
-            for code_block in self._function_injections[func_name]:
-                if isinstance(code_block, ASTNode):
-                    if code_block.type == 'action_block':
-                        for child in code_block.children:
-                            self._execute_node(child)
-                    else:
-                        self._execute_node(code_block)
+            self._injection_executing = True
+            try:
+                for code_block in self._function_injections[func_name]:
+                    if isinstance(code_block, ASTNode):
+                        if code_block.type == 'action_block':
+                            for child in code_block.children:
+                                self._execute_node(child)
+                        else:
+                            self._execute_node(code_block)
+            finally:
+                self._injection_executing = False
 
     # Output functions for builtins
     def set_output_callback(self, callback: Callable[[str, str], None]):