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

includecpp/core/cppy_converter.py

@@ -25,6 +25,65 @@ def _safe_get(lst: List[Any], index: int, default: Any = None) -> Any:
     return default
 
 
+# v3.3.22: Python reserved keywords - names that need escaping when used as identifiers
+PYTHON_KEYWORDS = {
+    'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
+    'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
+    'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
+    'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
+    'while', 'with', 'yield'
+}
+
+# v3.4.1: C++ reserved words that need escaping when used as Python identifiers
+# These are C++ types/keywords that are valid Python identifiers but confusing
+CPP_RESERVED_WORDS = {
+    # Primitive types
+    'int', 'float', 'double', 'char', 'bool', 'void', 'auto',
+    'short', 'long', 'signed', 'unsigned', 'wchar_t',
+    # Type modifiers
+    'const', 'static', 'virtual', 'volatile', 'mutable', 'extern',
+    'register', 'inline', 'explicit', 'constexpr', 'consteval',
+    # Access modifiers
+    'public', 'private', 'protected',
+    # Other keywords
+    'template', 'typename', 'namespace', 'using', 'typedef',
+    'struct', 'union', 'enum', 'sizeof', 'alignof', 'decltype',
+    'new', 'delete', 'operator', 'friend', 'this',
+    'throw', 'catch', 'noexcept', 'final', 'override',
+}
+
+
+def _escape_python_keyword(name: str) -> str:
+    """Escape Python reserved keywords by adding underscore suffix.
+
+    Example: 'class' -> 'class_', 'def' -> 'def_', 'import' -> 'import_'
+    """
+    if name in PYTHON_KEYWORDS:
+        return name + '_'
+    return name
+
+
+def _escape_cpp_reserved(name: str) -> str:
+    """Escape C++ reserved words when used as Python identifiers.
+
+    Example: 'double' -> 'double_', 'int' -> 'int_', 'void' -> 'void_'
+    v3.4.1: Prevents C++ type names from being used as Python function/variable names.
+    """
+    if name in CPP_RESERVED_WORDS:
+        return name + '_'
+    return name
+
+
+def _escape_identifier(name: str) -> str:
+    """Escape both Python keywords and C++ reserved words.
+
+    Combines both escaping functions for comprehensive identifier safety.
+    """
+    name = _escape_python_keyword(name)
+    name = _escape_cpp_reserved(name)
+    return name
+
+
 # Python type to C++ type mapping
 PY_TO_CPP_TYPES = {
     'int': 'int',
@@ -2205,11 +2264,31 @@ class CppToPythonConverter:
 
     def _parse_class_fields(self, body: str) -> List[Tuple[str, str, Optional[str]]]:
         fields = []
+        all_field_names = set()  # v3.4.1: Track ALL fields for self. prefix
 
+        # v3.4.1: Parse fields from ALL sections (public, private, protected)
+        # for self. prefix detection, but only return public fields for dataclass
         sections = re.split(r'(?:public|private|protected)\s*:', body)
-        public_section = sections[1] if len(sections) > 1 else body
 
         field_pattern = r'(\w+(?:<[^>]+>)?)\s+(\w+)\s*(?:=\s*([^;]+))?\s*;'
+
+        # First pass: collect ALL field names from all sections
+        for section in sections:
+            for match in re.finditer(field_pattern, section):
+                field_type = match.group(1)
+                field_name = match.group(2)
+
+                if '(' in field_type or field_type in ('return', 'if', 'for', 'while'):
+                    continue
+
+                all_field_names.add(field_name)
+
+        # Store all field names for self. prefix detection
+        self._current_class_fields = all_field_names
+
+        # Second pass: return only public fields for the Python class definition
+        public_section = sections[1] if len(sections) > 1 else body
+
         for match in re.finditer(field_pattern, public_section):
             field_type = match.group(1)
             field_name = match.group(2)
@@ -2500,18 +2579,20 @@ class CppToPythonConverter:
             if var_name not in ('if', 'for', 'while', 'return'):
                 return f'{var_name} = {self._get_default_value(var_type)}'
 
-        # Assignment
-        assign_match = re.match(r'(\w+(?:\.\w+)*(?:\[[^\]]+\])?)\s*=\s*(.+)$', stmt)
+        # Assignment - v3.3.22: Expanded pattern to capture -> and ::
+        assign_match = re.match(r'([a-zA-Z_][\w:>-]*(?:->|\.)?[a-zA-Z_][\w]*(?:\[[^\]]+\])?)\s*=\s*(.+)$', stmt)
         if assign_match:
             target = assign_match.group(1)
-            target = target.replace('this->', 'self.')
+            # v3.3.22: Apply full expression conversion to target as well
+            target = self._convert_cpp_expr(target)
             value = self._convert_cpp_expr(assign_match.group(2))
             return f'{target} = {value}'
 
         # Augmented assignment
         aug_match = re.match(r'(\w+(?:\.\w+)*)\s*(\+\+|--|\+=|-=|\*=|/=)', stmt)
         if aug_match:
-            target = aug_match.group(1).replace('this->', 'self.')
+            # v3.3.22: Apply full expression conversion to target
+            target = self._convert_cpp_expr(aug_match.group(1))
             op = aug_match.group(2)
             if op == '++':
                 return f'{target} += 1'
@@ -2572,13 +2653,30 @@ class CppToPythonConverter:
         expr = re.sub(r'std::max\(([^,]+),\s*([^)]+)\)', r'max(\1, \2)', expr)
 
         # Handle std::accumulate(container.begin(), container.end(), init) -> sum(container) [+ init]
+        # v3.4.1: Also handle accumulate without std:: prefix
         def _accumulate_to_sum(m):
             container = m.group(1)
             init_val = m.group(2).strip()
             if init_val == '0' or init_val == '0.0':
                 return f'sum({container})'
             return f'sum({container}) + {init_val}'
-        expr = re.sub(r'std::accumulate\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', _accumulate_to_sum, expr)
+        expr = re.sub(r'(?:std::)?accumulate\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', _accumulate_to_sum, expr)
+
+        # v3.4.1: Handle std::find, std::count, std::sort with .begin()/.end()
+        # std::find(vec.begin(), vec.end(), val) -> val in vec
+        expr = re.sub(r'(?:std::)?find\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)\s*!=\s*\1\.end\(\)', r'\2 in \1', expr)
+        # std::count(vec.begin(), vec.end(), val) -> vec.count(val)
+        expr = re.sub(r'(?:std::)?count\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', r'\1.count(\2)', expr)
+        # std::sort(vec.begin(), vec.end()) -> vec.sort()
+        expr = re.sub(r'(?:std::)?sort\((\w+)\.begin\(\),\s*\1\.end\(\)\)', r'\1.sort()', expr)
+        # std::reverse(vec.begin(), vec.end()) -> vec.reverse()
+        expr = re.sub(r'(?:std::)?reverse\((\w+)\.begin\(\),\s*\1\.end\(\)\)', r'\1.reverse()', expr)
+
+        # v3.4.1: Clean up any remaining .begin()/.end() that couldn't be converted
+        # container.begin() -> iter(container) for iteration context
+        # But typically these are errors - flag as comment if they remain
+        expr = re.sub(r'(\w+)\.begin\(\)', r'\1[0]', expr)  # Approximate as first element
+        expr = re.sub(r'(\w+)\.end\(\)', r'len(\1)', expr)  # Approximate as length
 
         # Handle .size() -> len()
         expr = re.sub(r'(\w+)\.size\(\)', r'len(\1)', expr)
@@ -2617,33 +2715,53 @@ class CppToPythonConverter:
         # Handle negation !
         expr = re.sub(r'!(\w)', r'not \1', expr)
 
-        # Add self. prefix for class member access (when not already prefixed)
+        # v3.3.22: Add self. prefix for class member access (when not already prefixed)
         if self._current_class_fields:
             for field in self._current_class_fields:
                 # Match field name that's not already prefixed with self. or another identifier
-                expr = re.sub(rf'(?<![.\w])(?<!self\.){re.escape(field)}(?=\s*[=,)\];\s]|$)', f'self.{field}', expr)
+                # Fixed lookahead to be more permissive - match non-word chars or end
+                expr = re.sub(rf'(?<![.\w])(?<!self\.){re.escape(field)}(?=\W|$)', f'self.{field}', expr)
+
+        # v3.4.1: Handle common C++ member naming conventions
+        # Convert m_name to self.name when in class context
+        if self._current_class_fields:
+            # Convert m_xxx to self.xxx
+            expr = re.sub(r'(?<![.\w])m_(\w+)(?=\W|$)', r'self.\1', expr)
+            # Convert _xxx to self.xxx (leading underscore)
+            expr = re.sub(r'(?<![.\w])_(\w+)(?=\W|$)', r'self.\1', expr)
+            # v3.4.1: Convert xxx_ to self.xxx_ (trailing underscore - Google style)
+            # Only if it's a known field or matches the pattern
+            for field in self._current_class_fields:
+                if field.endswith('_') and field not in ('self_',):
+                    expr = re.sub(rf'(?<![.\w]){re.escape(field)}(?=\W|$)', f'self.{field}', expr)
 
         return expr
 
     def _generate_struct(self, struct: StructInfo) -> List[str]:
         lines = ['@dataclass']
-        lines.append(f'class {struct.name}:')
+        # v3.4.1: Escape Python keywords and C++ reserved words in struct/class names
+        struct_name = _escape_identifier(struct.name)
+        lines.append(f'class {struct_name}:')
 
         if not struct.fields:
             lines.append(f'{self.indent}pass')
         else:
             for fname, ftype in struct.fields:
-                lines.append(f'{self.indent}{fname}: {ftype}')
+                # v3.4.1: Escape Python keywords and C++ reserved words in field names
+                escaped_fname = _escape_identifier(fname)
+                lines.append(f'{self.indent}{escaped_fname}: {ftype}')
 
         return lines
 
     def _generate_class(self, cls: ClassInfo) -> List[str]:
         lines = []
 
+        # v3.4.1: Escape Python keywords and C++ reserved words in class names
+        class_name = _escape_identifier(cls.name)
         if cls.bases:
-            lines.append(f'class {cls.name}({", ".join(cls.bases)}):')
+            lines.append(f'class {class_name}({", ".join(cls.bases)}):')
         else:
-            lines.append(f'class {cls.name}:')
+            lines.append(f'class {class_name}:')
 
         if not cls.fields and not cls.methods and not cls.constructors:
             lines.append(f'{self.indent}pass')
@@ -2665,16 +2783,19 @@ class CppToPythonConverter:
 
         params = ['self'] if not method.is_static else []
         for pname, ptype in method.params:
+            # v3.4.1: Escape Python keywords and C++ reserved words in parameter names
+            escaped_pname = _escape_identifier(pname)
             if ptype and ptype != 'Any':
-                params.append(f'{pname}: {ptype}')
+                params.append(f'{escaped_pname}: {ptype}')
             else:
-                params.append(pname)
+                params.append(escaped_pname)
 
         ret_type = ''
         if not is_init and method.return_type and method.return_type != 'None':
             ret_type = f' -> {method.return_type}'
 
-        method_name = '__init__' if is_init else method.name
+        # v3.4.1: Escape Python keywords and C++ reserved words in method names
+        method_name = '__init__' if is_init else _escape_identifier(method.name)
         lines.append(f'{self.indent}def {method_name}({", ".join(params)}){ret_type}:')
 
         body_lines = method.body.split('\n')
@@ -2691,16 +2812,20 @@ class CppToPythonConverter:
 
         params = []
         for pname, ptype in func.params:
+            # v3.4.1: Escape Python keywords and C++ reserved words in parameter names
+            escaped_pname = _escape_identifier(pname)
             if ptype and ptype != 'Any':
-                params.append(f'{pname}: {ptype}')
+                params.append(f'{escaped_pname}: {ptype}')
             else:
-                params.append(pname)
+                params.append(escaped_pname)
 
         ret_type = ''
         if func.return_type and func.return_type != 'None':
             ret_type = f' -> {func.return_type}'
 
-        lines.append(f'def {func.name}({", ".join(params)}){ret_type}:')
+        # v3.4.1: Escape Python keywords and C++ reserved words in function names
+        func_name = _escape_identifier(func.name)
+        lines.append(f'def {func_name}({", ".join(params)}){ret_type}:')
 
         body_lines = func.body.split('\n')
         if body_lines and body_lines[0].strip():

includecpp/core/cssl/__init__.py

@@ -0,0 +1,40 @@
+"""
+CSSL - CSO Service Script Language
+Bundled with IncludeCPP for integrated scripting support.
+
+Features:
+- BruteForce Injection System: <==, ==>, +<==, -<==, <<==, ==>>
+- Dynamic typing with 'dynamic' keyword
+- Function modifiers: undefined, open, meta, super, closed, private, virtual
+- Advanced data types: datastruct, shuffled, iterator, combo, dataspace
+- Injection helpers: string::where, json::key, array::index, etc.
+- Global references: @Name, r@Name, s@Name
+"""
+
+from .cssl_parser import (
+    parse_cssl, parse_cssl_program, tokenize_cssl,
+    CSSLSyntaxError, CSSLLexer, CSSLParser, ASTNode,
+    KEYWORDS, TYPE_GENERICS, INJECTION_HELPERS
+)
+from .cssl_runtime import CSSLRuntime, CSSLRuntimeError, CSSLServiceRunner, run_cssl, run_cssl_file
+from .cssl_types import (
+    DataStruct, Shuffled, Iterator, Combo, DataSpace, OpenQuote,
+    OpenFind, Parameter,
+    create_datastruct, create_shuffled, create_iterator,
+    create_combo, create_dataspace, create_openquote, create_parameter
+)
+
+__all__ = [
+    # Parser
+    'parse_cssl', 'parse_cssl_program', 'tokenize_cssl',
+    'CSSLSyntaxError', 'CSSLLexer', 'CSSLParser', 'ASTNode',
+    'KEYWORDS', 'TYPE_GENERICS', 'INJECTION_HELPERS',
+    # Runtime
+    'CSSLRuntime', 'CSSLRuntimeError', 'CSSLServiceRunner',
+    'run_cssl', 'run_cssl_file',
+    # Data Types
+    'DataStruct', 'Shuffled', 'Iterator', 'Combo', 'DataSpace', 'OpenQuote',
+    'OpenFind', 'Parameter',
+    'create_datastruct', 'create_shuffled', 'create_iterator',
+    'create_combo', 'create_dataspace', 'create_openquote', 'create_parameter'
+]