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

includecpp/core/cssl/cssl_parser.py

@@ -99,6 +99,7 @@ class TokenType(Enum):
     AT = auto()
     GLOBAL_REF = auto()  # r@<name> global variable declaration
     SELF_REF = auto()    # s@<name> self-reference to global struct
+    SHARED_REF = auto()  # $<name> shared object reference
     PACKAGE = auto()
     PACKAGE_INCLUDES = auto()
     AS = auto()
@@ -154,6 +155,11 @@ TYPE_GENERICS = {
     'vector', 'stack', 'array', 'openquote'
 }
 
+# Functions that accept type parameters: FuncName<type>(args)
+TYPE_PARAM_FUNCTIONS = {
+    'OpenFind'  # OpenFind<string>(0)
+}
+
 # Injection helper prefixes (type::helper=value)
 INJECTION_HELPERS = {
     'string', 'integer', 'json', 'array', 'vector', 'combo', 'dynamic', 'sql'
@@ -232,6 +238,9 @@ class CSSLLexer:
             elif char == '@':
                 self._add_token(TokenType.AT, '@')
                 self._advance()
+            elif char == '$':
+                # $<name> shared object reference
+                self._read_shared_ref()
             elif char == '&':
                 # & for references
                 if self._peek(1) == '&':
@@ -470,6 +479,20 @@ class CSSLLexer:
         value = self.source[name_start:self.pos]
         self._add_token(TokenType.GLOBAL_REF, value)
 
+    def _read_shared_ref(self):
+        """Read $<name> shared object reference"""
+        self._advance()  # skip '$'
+
+        # Read the identifier (shared object name)
+        name_start = self.pos
+        while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+            self._advance()
+
+        value = self.source[name_start:self.pos]
+        if not value:
+            self.error("Expected identifier after '$'")
+        self._add_token(TokenType.SHARED_REF, value)
+
     def _read_less_than(self):
         # Check for <<== (code infusion left)
         if self._peek(1) == '<' and self._peek(2) == '=' and self._peek(3) == '=':
@@ -679,6 +702,44 @@ class CSSLParser:
         self.pos = saved_pos
         return False
 
+    def _looks_like_typed_variable(self) -> bool:
+        """Check if current position looks like a typed variable declaration.
+
+        Patterns:
+        - int x;
+        - stack<string> myStack;
+        - vector<int> nums = [1,2,3];
+
+        Distinguishes from function declarations by checking for '(' after identifier.
+        """
+        saved_pos = self.pos
+
+        # 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 NOT followed by ( (that would be a function)
+            if self._check(TokenType.IDENTIFIER):
+                self._advance()
+                # If followed by '(' it's a function, not a variable
+                is_var = not self._check(TokenType.PAREN_START)
+                self.pos = saved_pos
+                return is_var
+
+        self.pos = saved_pos
+        return False
+
     def _parse_typed_function(self) -> ASTNode:
         """Parse C-style typed function declaration.
 
@@ -800,6 +861,78 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _looks_like_typed_variable(self) -> bool:
+        """Check if current position looks like a typed variable declaration:
+        type_name varName; or type_name<T> varName; or type_name varName = value;
+        """
+        # Save position
+        saved_pos = self.pos
+
+        # Must start with a type keyword (int, string, stack, vector, etc.)
+        if not self._check(TokenType.KEYWORD):
+            return False
+
+        type_name = self._current().value
+
+        # Skip known type keywords
+        type_keywords = {'int', 'string', 'float', 'bool', 'dynamic', 'void',
+                        'stack', 'vector', 'datastruct', 'dataspace', 'shuffled',
+                        'iterator', 'combo', 'array', 'openquote', 'json'}
+        if type_name not in type_keywords:
+            return False
+
+        self._advance()
+
+        # Check for optional generic <T>
+        if self._match(TokenType.COMPARE_LT):
+            # Skip until >
+            depth = 1
+            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()
+
+        # Next should be an identifier (variable name), not '(' (function) or ';'
+        result = self._check(TokenType.IDENTIFIER)
+
+        # Restore position
+        self.pos = saved_pos
+        return result
+
+    def _parse_typed_variable(self) -> Optional[ASTNode]:
+        """Parse a typed variable declaration: type varName; or type<T> varName = value;"""
+        # Get type name
+        type_name = self._advance().value  # Consume type keyword
+
+        # Check for generic type <T>
+        element_type = None
+        if self._match(TokenType.COMPARE_LT):
+            # Get element type
+            if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+                element_type = self._advance().value
+            self._expect(TokenType.COMPARE_GT)
+
+        # Get variable name
+        if not self._check(TokenType.IDENTIFIER):
+            return None
+        var_name = self._advance().value
+
+        # Check for assignment or just declaration
+        value = None
+        if self._match(TokenType.EQUALS):
+            value = self._parse_expression()
+
+        self._match(TokenType.SEMICOLON)
+
+        return ASTNode('typed_declaration', value={
+            'type': type_name,
+            'element_type': element_type,
+            'name': var_name,
+            'value': value
+        })
+
     def parse_program(self) -> ASTNode:
         """Parse a standalone program (no service wrapper)"""
         root = ASTNode('program', children=[])
@@ -812,6 +945,11 @@ class CSSLParser:
             # Check for C-style typed function declarations
             elif self._looks_like_function_declaration():
                 root.children.append(self._parse_typed_function())
+            # Check for typed variable declarations (int x;, stack<string> s;)
+            elif self._looks_like_typed_variable():
+                decl = self._parse_typed_variable()
+                if decl:
+                    root.children.append(decl)
             # Handle service blocks
             elif self._match_keyword('service-init'):
                 root.children.append(self._parse_service_init())
@@ -827,13 +965,17 @@ class CSSLParser:
             elif self._match_keyword('global'):
                 stmt = self._parse_expression_statement()
                 if stmt:
-                    root.children.append(stmt)
+                    # Wrap in global_assignment to mark as global variable
+                    global_stmt = ASTNode('global_assignment', value=stmt)
+                    root.children.append(global_stmt)
             elif self._check(TokenType.GLOBAL_REF):
                 stmt = self._parse_expression_statement()
                 if stmt:
-                    root.children.append(stmt)
+                    # Wrap in global_assignment to mark as global variable (same as 'global' keyword)
+                    global_stmt = ASTNode('global_assignment', value=stmt)
+                    root.children.append(global_stmt)
             # Handle statements
-            elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or self._check(TokenType.SELF_REF):
+            elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or self._check(TokenType.SELF_REF) or self._check(TokenType.SHARED_REF):
                 stmt = self._parse_expression_statement()
                 if stmt:
                     root.children.append(stmt)
@@ -1143,6 +1285,9 @@ class CSSLParser:
         elif self._match_keyword('define'):
             # Nested define function
             return self._parse_define()
+        elif self._looks_like_typed_variable():
+            # Typed variable declaration (e.g., stack<string> myStack;)
+            return self._parse_typed_variable()
         elif self._looks_like_function_declaration():
             # Nested typed function (e.g., void Level2() { ... })
             return self._parse_typed_function()
@@ -1153,6 +1298,7 @@ class CSSLParser:
             return None
 
     def _parse_if(self) -> ASTNode:
+        """Parse if statement with support for else if AND elif syntax."""
         self._expect(TokenType.PAREN_START)
         condition = self._parse_expression()
         self._expect(TokenType.PAREN_END)
@@ -1168,7 +1314,13 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         node.children.append(then_block)
 
-        if self._match_keyword('else'):
+        # Support both 'else if' AND 'elif' syntax
+        if self._match_keyword('elif'):
+            # elif is shorthand for else if
+            else_block = ASTNode('else', children=[])
+            else_block.children.append(self._parse_if())
+            node.children.append(else_block)
+        elif self._match_keyword('else'):
             else_block = ASTNode('else', children=[])
             if self._match_keyword('if'):
                 else_block.children.append(self._parse_if())
@@ -1200,18 +1352,186 @@ class CSSLParser:
         return node
 
     def _parse_for(self) -> ASTNode:
+        """Parse for loop - supports both syntaxes:
+
+        Python-style: for (i in range(0, n)) { }
+        C-style: for (int i = 0; i < n; i = i + 1) { }
+                 for (i = 0; i < n; i++) { }
+        """
         self._expect(TokenType.PAREN_START)
+
+        # Detect C-style by checking for semicolons in the for header
+        # Look ahead without consuming tokens
+        is_c_style = self._detect_c_style_for()
+
+        if is_c_style:
+            # C-style: for (init; condition; update) { }
+            return self._parse_c_style_for()
+        else:
+            # Python-style: for (var in range(start, end)) { }
+            return self._parse_python_style_for()
+
+    def _detect_c_style_for(self) -> bool:
+        """Detect if this is a C-style for loop by looking for semicolons."""
+        # Scan the tokens list directly without modifying self.pos
+        pos = self.pos
+        paren_depth = 1
+
+        while pos < len(self.tokens) and paren_depth > 0:
+            token = self.tokens[pos]
+            if token.type == TokenType.PAREN_START:
+                paren_depth += 1
+            elif token.type == TokenType.PAREN_END:
+                paren_depth -= 1
+            elif token.type == TokenType.SEMICOLON and paren_depth == 1:
+                # Found semicolon at top level - C-style
+                return True
+            elif token.type == TokenType.KEYWORD and token.value == 'in':
+                # Found 'in' keyword - Python-style
+                return False
+            pos += 1
+
+        return False  # Default to Python-style
+
+    def _parse_c_style_for(self) -> ASTNode:
+        """Parse C-style for loop: for (init; condition; update) { }"""
+        # Parse init statement
+        init = None
+        if not self._check(TokenType.SEMICOLON):
+            # Check if it's a typed declaration: int i = 0
+            if self._check(TokenType.KEYWORD) and self._peek().value in ('int', 'float', 'string', 'bool', 'dynamic'):
+                type_name = self._advance().value
+                var_name = self._advance().value
+                self._expect(TokenType.EQUALS)
+                value = self._parse_expression()
+                init = ASTNode('c_for_init', value={
+                    'type': type_name,
+                    'var': var_name,
+                    'value': value
+                })
+            else:
+                # Simple assignment: i = 0
+                var_name = self._advance().value
+                self._expect(TokenType.EQUALS)
+                value = self._parse_expression()
+                init = ASTNode('c_for_init', value={
+                    'type': None,
+                    'var': var_name,
+                    'value': value
+                })
+
+        self._expect(TokenType.SEMICOLON)
+
+        # Parse condition
+        condition = None
+        if not self._check(TokenType.SEMICOLON):
+            condition = self._parse_expression()
+
+        self._expect(TokenType.SEMICOLON)
+
+        # Parse update statement
+        update = None
+        if not self._check(TokenType.PAREN_END):
+            # Could be: i = i + 1, i++, ++i, i += 1
+            update = self._parse_c_for_update()
+
+        self._expect(TokenType.PAREN_END)
+
+        node = ASTNode('c_for', value={
+            'init': init,
+            'condition': condition,
+            'update': update
+        }, 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_c_for_update(self) -> ASTNode:
+        """Parse the update part of a C-style for loop.
+
+        Supports: i = i + 1, i++, ++i, i += 1, i -= 1
+        """
+        # Check for prefix increment/decrement: ++i or --i
+        if self._check(TokenType.PLUS) or self._check(TokenType.MINUS):
+            op_token = self._advance()
+            # Check for double operator (++ or --)
+            if self._check(op_token.type):
+                self._advance()
+                var_name = self._advance().value
+                op = 'increment' if op_token.type == TokenType.PLUS else 'decrement'
+                return ASTNode('c_for_update', value={'var': var_name, 'op': op})
+
+        # Regular variable assignment or postfix
+        var_name = self._advance().value
+
+        # Check for postfix increment/decrement: i++ or i--
+        if self._check(TokenType.PLUS):
+            self._advance()
+            if self._check(TokenType.PLUS):
+                self._advance()
+                return ASTNode('c_for_update', value={'var': var_name, 'op': 'increment'})
+            else:
+                # i += value
+                if self._check(TokenType.EQUALS):
+                    self._advance()
+                    value = self._parse_expression()
+                    return ASTNode('c_for_update', value={'var': var_name, 'op': 'add', 'value': value})
+        elif self._check(TokenType.MINUS):
+            self._advance()
+            if self._check(TokenType.MINUS):
+                self._advance()
+                return ASTNode('c_for_update', value={'var': var_name, 'op': 'decrement'})
+            else:
+                # i -= value
+                if self._check(TokenType.EQUALS):
+                    self._advance()
+                    value = self._parse_expression()
+                    return ASTNode('c_for_update', value={'var': var_name, 'op': 'subtract', 'value': value})
+
+        # Regular assignment: i = expression
+        if self._check(TokenType.EQUALS):
+            self._advance()
+            value = self._parse_expression()
+            return ASTNode('c_for_update', value={'var': var_name, 'op': 'assign', 'value': value})
+
+        # Just the variable (shouldn't happen but handle it)
+        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(start, end)) { }"""
         var_name = self._advance().value
-        self._expect(TokenType.KEYWORD)
-        self._expect(TokenType.KEYWORD)
+        self._expect(TokenType.KEYWORD)  # 'in'
+
+        # 'range' can be keyword or identifier
+        if self._check(TokenType.KEYWORD) and self._peek().value == 'range':
+            self._advance()  # consume 'range' keyword
+        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}")
+
         self._expect(TokenType.PAREN_START)
         start = self._parse_expression()
         self._expect(TokenType.COMMA)
         end = self._parse_expression()
+
+        # Optional step parameter: range(start, end, step)
+        step = None
+        if self._check(TokenType.COMMA):
+            self._advance()  # consume comma
+            step = self._parse_expression()
+
         self._expect(TokenType.PAREN_END)
         self._expect(TokenType.PAREN_END)
 
-        node = ASTNode('for', value={'var': var_name, 'start': start, 'end': end}, children=[])
+        node = ASTNode('for', value={'var': var_name, 'start': start, 'end': end, 'step': step}, children=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1640,6 +1960,56 @@ class CSSLParser:
                 node = ASTNode('call', value={'callee': node, 'args': args})
             return node
 
+        if self._check(TokenType.GLOBAL_REF):
+            # r@<name> global variable reference/declaration
+            token = self._advance()
+            node = ASTNode('global_ref', value=token.value, line=token.line, column=token.column)
+            # Check for member access, calls, indexing
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    args = []
+                    while not self._check(TokenType.PAREN_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 = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                elif self._match(TokenType.BRACKET_START):
+                    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.SHARED_REF):
+            # $<name> shared object reference
+            token = self._advance()
+            node = ASTNode('shared_ref', value=token.value, line=token.line, column=token.column)
+            # Check for member access, calls, indexing
+            while True:
+                if self._match(TokenType.PAREN_START):
+                    args = []
+                    while not self._check(TokenType.PAREN_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 = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                elif self._match(TokenType.BRACKET_START):
+                    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.NUMBER):
             return ASTNode('literal', value=self._advance().value)
 
@@ -1675,16 +2045,81 @@ class CSSLParser:
         return ASTNode('literal', value=None)
 
     def _parse_module_reference(self) -> ASTNode:
-        parts = []
-        parts.append(self._advance().value)
+        """Parse @name, handling method calls and property access.
+
+        @name alone -> module_ref
+        @name.method() -> call with member_access
+        @name.property -> member_access
+        """
+        # Get base name
+        name = self._advance().value
+        node = ASTNode('module_ref', value=name)
 
-        while self._match(TokenType.DOT):
-            parts.append(self._advance().value)
+        # Continue to handle member access, calls, and indexing
+        while True:
+            if self._match(TokenType.DOT):
+                member = self._advance().value
+                node = ASTNode('member_access', value={'object': node, 'member': member})
+            elif self._match(TokenType.PAREN_START):
+                # Function call
+                args = []
+                while not self._check(TokenType.PAREN_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.BRACKET_START):
+                # Index access
+                index = self._parse_expression()
+                self._expect(TokenType.BRACKET_END)
+                node = ASTNode('index_access', value={'object': node, 'index': index})
+            else:
+                break
 
-        return ASTNode('module_ref', value='.'.join(parts))
+        return node
 
     def _parse_identifier_or_call(self) -> ASTNode:
         name = self._advance().value
+
+        # Check for type generic instantiation: stack<string>, vector<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'
+            if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+                element_type = self._advance().value
+            self._expect(TokenType.COMPARE_GT)  # consume >
+            return ASTNode('type_instantiation', value={
+                'type': name,
+                'element_type': element_type
+            })
+
+        # Check for type-parameterized function call: OpenFind<string>(0)
+        if name in TYPE_PARAM_FUNCTIONS and self._check(TokenType.COMPARE_LT):
+            self._advance()  # consume <
+            type_param = 'dynamic'
+            if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+                type_param = self._advance().value
+            self._expect(TokenType.COMPARE_GT)  # consume >
+
+            # Must be followed by ()
+            if self._check(TokenType.PAREN_START):
+                self._advance()  # consume (
+                args = []
+                while not self._check(TokenType.PAREN_END):
+                    args.append(self._parse_expression())
+                    if not self._check(TokenType.PAREN_END):
+                        self._expect(TokenType.COMMA)
+                self._expect(TokenType.PAREN_END)
+
+                # Return as typed function call
+                return ASTNode('typed_call', value={
+                    'name': name,
+                    'type_param': type_param,
+                    'args': args
+                })
+
         node = ASTNode('identifier', value=name)
 
         while True: