code-explore-by-sql 0.1.0__py3-none-any.whl

code_source_sql/languages/glsl.py

@@ -0,0 +1,162 @@
+"""GLSL (OpenGL Shading Language) configuration.
+
+Supports struct, uniform blocks, buffer blocks (SSBO), layout() qualifiers,
+and standard C-like function syntax. No classes, namespaces, templates, or
+semantic annotations.
+"""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+_NEVER_MATCH = re.compile(r"(?!x)x")
+
+
+def make_glsl_language() -> LanguageConfig:
+    """GLSL language configuration — C-like shader language for OpenGL/Vulkan."""
+    return LanguageConfig(
+        name="glsl",
+        # Only struct — no class or interface in GLSL
+        class_re=re.compile(
+            r"(?:^|\s)(struct)\s+"
+            r"(\w+)"
+            r"\s*",
+        ),
+        # No enums in GLSL
+        enum_re=_NEVER_MATCH,
+        # No namespaces in GLSL
+        namespace_re=_NEVER_MATCH,
+        func_name_re=re.compile(r"(\w+)\s*\([^)]*\)\s*$"),
+        # No export macros
+        export_macro_re=_NEVER_MATCH,
+        # No calling conventions
+        calling_conv_re=_NEVER_MATCH,
+        # Strip layout(...) qualifiers before classification
+        attribute_re=re.compile(
+            r"\blayout\s*\([^)]*\)\s*"
+        ),
+        # No templates
+        template_re=_NEVER_MATCH,
+        # No destructors
+        dtor_re=_NEVER_MATCH,
+        control_flow_re=re.compile(r"\b(if|else\s+if|else|while|for|do|switch)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "switch",
+            "return", "break", "continue", "discard",
+        }),
+        # Includes precision qualifiers
+        trailing_mods_re=re.compile(
+            r"\s*(?:const|highp|mediump|lowp)\s*[;{]*\s*$"
+        ),
+        # No access specifiers
+        access_spec_re=_NEVER_MATCH,
+        macro_like_re=re.compile(r"^[A-Z][A-Z0-9_]*\s*(?:\([^{};]*\))?\s*$"),
+        define_re=re.compile(r"#\s*define\s+"),
+        # No extern "C"
+        extern_c_re=_NEVER_MATCH,
+        # No operator overloading
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=False,
+        # Edge extraction
+        scope_operator="::",
+        base_keyword="",
+        static_call_re=None,
+        super_call_re=None,
+        # PascalCase user-defined struct types
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(
+            r"(?:const\s+)?([A-Z][A-Za-z0-9_]+)\s+\w+"
+        ),
+        basic_skip_types=frozenset({
+            # Scalar types
+            "float", "double", "int", "uint", "bool", "void",
+            # Vector types
+            "vec2", "vec3", "vec4",
+            "ivec2", "ivec3", "ivec4",
+            "uvec2", "uvec3", "uvec4",
+            "bvec2", "bvec3", "bvec4",
+            "dvec2", "dvec3", "dvec4",
+            # Matrix types
+            "mat2", "mat3", "mat4",
+            "mat2x2", "mat2x3", "mat2x4",
+            "mat3x2", "mat3x3", "mat3x4",
+            "mat4x2", "mat4x3", "mat4x4",
+            "dmat2", "dmat3", "dmat4",
+            # Sampler types
+            "sampler2D", "sampler3D", "samplerCube",
+            "sampler2DShadow", "samplerCubeShadow",
+            "sampler2DArray", "sampler2DArrayShadow",
+            "sampler1D", "sampler1DShadow",
+            "samplerBuffer", "sampler2DRect",
+            "sampler2DMS", "sampler2DMSArray",
+            "isampler2D", "isampler3D", "isamplerCube",
+            "usampler2D", "usampler3D", "usamplerCube",
+            # Image types
+            "image2D", "image3D", "imageCube", "imageBuffer",
+            "iimage2D", "uimage2D",
+            # Atomic types
+            "atomic_uint",
+            # Storage/precision qualifiers (noise when used as type-like tokens)
+            "in", "out", "inout", "uniform", "const",
+            "attribute", "varying",
+            "highp", "mediump", "lowp",
+            "readonly", "writeonly", "coherent",
+        }),
+        # Block classification helpers
+        block_keyword_re=re.compile(
+            r"\b(?:struct|uniform|buffer)\b"
+        ),
+        # No lambdas
+        lambda_re=None,
+        # uniform/buffer blocks recognized as namespace-like blocks
+        # attribute_re already stripped layout(...), leaving clean "uniform Name"
+        namespace_sig_re=re.compile(
+            r"(?:uniform|buffer)\s+(\w+)\s*$"
+        ),
+        init_list_re=None,
+        # View / summary helpers
+        access_spec_names=frozenset(),
+        view_structural_kws=("struct ", "uniform ", "buffer "),
+        view_modifier_kws=("const ", "static "),
+        local_var_modifiers="const|uniform|volatile|highp|mediump|lowp|readonly|writeonly|coherent",
+        # Bracket scanner hints
+        verbatim_string_prefix=None,
+        raw_string_char=None,
+        # No range-based for in GLSL
+        range_for_re=None,
+        # Comment syntax (same as C)
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax — only double-quoted strings in GLSL
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="#",
+        has_preprocessor_macros=True,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="};",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s*\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=re.compile(r"#\s*define\s+(\w+)(\([^)]*\))?\s*(.*)"),
+        has_template_strings=False,
+        raw_string_style="cpp",
+        # No semantic annotations in GLSL — standard C function signature end
+        func_sig_end_re=re.compile(r"\)\s*$"),
+    )

code_source_sql/languages/go.py

@@ -0,0 +1,91 @@
+"""Go language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+
+def make_go_language() -> LanguageConfig:
+    """Go language configuration."""
+    return LanguageConfig(
+        name="go",
+        class_re=re.compile(r"\b(type)\s+(\w+)\s+(?:struct|interface)\b(?:\s*(?://.*)?$)?"),
+        enum_re=re.compile(r"(?!x)x"),  # never-match; Go has no enum keyword
+        namespace_re=re.compile(r"(?!x)x"),  # never-match; Go uses package, not namespace blocks
+        func_name_re=re.compile(r"func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)\s*\("),
+        export_macro_re=re.compile(r"(?!x)x"),
+        calling_conv_re=re.compile(r"(?!x)x"),
+        attribute_re=re.compile(r"(?!x)x"),
+        template_re=re.compile(r"\[[^\]]+\]"),  # Go generics: [T any]
+        dtor_re=re.compile(r"(?!x)x"),
+        control_flow_re=re.compile(r"\b(if|else|for|range|switch|case|select|go|defer|return)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "for", "switch", "case", "select", "go", "defer",
+            "return", "break", "continue", "fallthrough", "goto", "range",
+        }),
+        trailing_mods_re=re.compile(r"(?!x)x"),
+        access_spec_re=re.compile(r"(?!x)x"),
+        macro_like_re=re.compile(r"(?!x)x"),
+        define_re=re.compile(r"(?!x)x"),
+        extern_c_re=re.compile(r"(?!x)x"),
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=False,
+        scope_operator=".",
+        base_keyword="",  # Go has no super/base; embedded fields accessed directly
+        static_call_re=re.compile(r"\b([A-Z][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        super_call_re=None,
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]*)\b"),  # exported names are PascalCase
+        param_type_re=re.compile(r"([A-Z][A-Za-z0-9_]*(?:<[^>]*>)?)\s+"),
+        basic_skip_types=frozenset({
+            "int", "int8", "int16", "int32", "int64",
+            "uint", "uint8", "uint16", "uint32", "uint64",
+            "float32", "float64", "string", "bool", "byte", "rune",
+            "error", "complex64", "complex128", "uintptr",
+        }),
+        block_keyword_re=re.compile(r"\b(?:func|type|struct|interface|map|chan)\b"),
+        lambda_re=re.compile(r"func\s*\("),  # Go anonymous functions
+        namespace_sig_re=None,
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=("type ", "func "),
+        view_modifier_kws=("go ", "defer "),
+        local_var_modifiers="var|const",
+        verbatim_string_prefix=None,
+        raw_string_char=None,  # Go uses backtick for raw strings
+        range_for_re=re.compile(
+            r"for\s+(?:\w+(?:,\s*\w+)?\s*:=\s+)?range\s+(\w+)"
+        ),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator="",  # Go has no semicolons
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s+(.{1,80})\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*if\s+(.{1,80})\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s+(.{1,40})\s*\{?\s*$")),
+            ("select", re.compile(r"^\s*select\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60})"),  # no semicolons in Go
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )

code_source_sql/languages/hlsl.py

@@ -0,0 +1,155 @@
+"""HLSL (High-Level Shading Language) configuration.
+
+Supports DirectX shader syntax including cbuffer, tbuffer, struct, interface,
+class (SM5), function semantic annotations (: SV_TARGET), and register() bindings.
+"""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+_NEVER_MATCH = re.compile(r"(?!x)x")
+
+
+def make_hlsl_language() -> LanguageConfig:
+    """HLSL language configuration — C-like shader language for DirectX."""
+    return LanguageConfig(
+        name="hlsl",
+        # struct + SM5 interface/class (group 3 = optional inheritance base)
+        class_re=re.compile(
+            r"(?:^|\s)(struct|interface|class)\s+"
+            r"(\w+)"
+            r"\s*(?::\s*(\w+))?",
+        ),
+        enum_re=re.compile(r"\benum\s+(\w+)"),
+        # No namespaces in HLSL
+        namespace_re=_NEVER_MATCH,
+        # Must tolerate trailing : SEMANTIC after closing paren
+        func_name_re=re.compile(r"(\w+)\s*\([^)]*\)\s*(?::\s*\w+\s*)?$"),
+        # No export macros
+        export_macro_re=_NEVER_MATCH,
+        # No calling conventions
+        calling_conv_re=_NEVER_MATCH,
+        # Strip register() and packoffset() binding annotations
+        attribute_re=re.compile(
+            r"\b(?:register|packoffset)\s*\([^)]*\)"
+        ),
+        # No templates
+        template_re=_NEVER_MATCH,
+        # No destructors
+        dtor_re=_NEVER_MATCH,
+        control_flow_re=re.compile(r"\b(if|else\s+if|else|while|for|do|switch)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "switch",
+            "return", "break", "continue", "discard",
+        }),
+        trailing_mods_re=re.compile(
+            r"\s*(?:const|inline|static)\s*[;{]*\s*$"
+        ),
+        # No access specifiers
+        access_spec_re=_NEVER_MATCH,
+        macro_like_re=re.compile(r"^[A-Z][A-Z0-9_]*\s*(?:\([^{};]*\))?\s*$"),
+        define_re=re.compile(r"#\s*define\s+"),
+        # No extern "C"
+        extern_c_re=_NEVER_MATCH,
+        # No operator overloading
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=True,
+        # Edge extraction
+        scope_operator="::",
+        base_keyword="",
+        static_call_re=None,
+        super_call_re=None,
+        # PascalCase types (Texture2D, SamplerState, user-defined structs)
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(
+            r"(?:const\s+)?([A-Z][A-Za-z0-9_]+)\s+(?:\*+|&)?\s*\w+"
+        ),
+        basic_skip_types=frozenset({
+            # Scalar types
+            "int", "uint", "float", "half", "double", "bool", "void", "dword",
+            # Vector types
+            "int2", "int3", "int4", "uint2", "uint3", "uint4",
+            "float2", "float3", "float4",
+            "half2", "half3", "half4",
+            "bool2", "bool3", "bool4",
+            "double2", "double3", "double4",
+            # Matrix types
+            "float2x2", "float2x3", "float2x4",
+            "float3x2", "float3x3", "float3x4",
+            "float4x2", "float4x3", "float4x4",
+            "int2x2", "int3x3", "int4x4",
+            # Sampler types
+            "SamplerState", "SamplerComparisonState",
+            # Texture types
+            "Texture1D", "Texture2D", "Texture3D", "TextureCube",
+            "Texture1DArray", "Texture2DArray", "TextureCubeArray",
+            "Texture2DMS", "Texture2DMSArray",
+            "RWTexture1D", "RWTexture2D", "RWTexture3D",
+            "RWTexture1DArray", "RWTexture2DArray",
+            # Buffer types
+            "Buffer", "RWBuffer",
+            "StructuredBuffer", "RWStructuredBuffer",
+            "ByteAddressBuffer", "RWByteAddressBuffer",
+            "AppendStructuredBuffer", "ConsumeStructuredBuffer",
+            # Parameter modifiers
+            "in", "out", "inout", "uniform",
+        }),
+        # Block classification helpers
+        block_keyword_re=re.compile(
+            r"\b(?:cbuffer|tbuffer|struct|interface|class|enum)\b"
+        ),
+        # No lambdas
+        lambda_re=None,
+        # cbuffer/tbuffer recognized as namespace-like blocks
+        # attribute_re already stripped register(b0), leaving optional trailing ":"
+        namespace_sig_re=re.compile(
+            r"(?:cbuffer|tbuffer)\s+(\w+)\s*(?::\s*)?$"
+        ),
+        init_list_re=None,
+        # View / summary helpers
+        access_spec_names=frozenset(),
+        view_structural_kws=("struct ", "cbuffer ", "tbuffer ", "interface ", "class "),
+        view_modifier_kws=("static ", "inline "),
+        local_var_modifiers="const|static|uniform|volatile",
+        # Bracket scanner hints
+        verbatim_string_prefix=None,
+        raw_string_char=None,
+        # No range-based for in HLSL
+        range_for_re=None,
+        # Comment syntax (same as C)
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax — only double-quoted strings in HLSL
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="#",
+        has_preprocessor_macros=True,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="};",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s*\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=re.compile(r"#\s*define\s+(\w+)(\([^)]*\))?\s*(.*)"),
+        has_template_strings=False,
+        raw_string_style="cpp",
+        # Function signature end — matches ) : SEMANTIC_NAME (HLSL semantic annotations)
+        func_sig_end_re=re.compile(r"\)\s*(?::\s*\w+\s*)?$"),
+    )

code_source_sql/languages/java.py

@@ -0,0 +1,98 @@
+"""Java language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+
+def make_java_language() -> LanguageConfig:
+    """Java language configuration."""
+    return LanguageConfig(
+        name="java",
+        class_re=re.compile(
+            r"(?:^|\s)(?:(?:public|private|protected|abstract|final|static)\s+)*"
+            r"(class|interface|enum)\s+(\w+)"
+            r"(?:\s+extends\s+(\w+))?"
+        ),
+        enum_re=re.compile(r"\benum\s+(\w+)"),
+        namespace_re=re.compile(r"(?!x)x"),  # never-match; Java packages are directory-based
+        func_name_re=re.compile(
+            r"(\w+)\s*\([^)]*\)\s*(?:throws\s+[\w,\s]+)?\s*\{?\s*$"
+        ),
+        export_macro_re=re.compile(r"(?!x)x"),
+        calling_conv_re=re.compile(r"(?!x)x"),
+        attribute_re=re.compile(r"@\w+(?:\.\w+)*(?:\([^)]*\))?"),  # annotations
+        template_re=re.compile(r"<[^<>]*>"),  # generics
+        dtor_re=re.compile(r"(?!x)x"),
+        control_flow_re=re.compile(r"\b(if|else\s+if|else|while|for|do|switch|catch|try|synchronized)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "switch", "catch", "try",
+            "return", "break", "continue", "throw", "synchronized", "assert", "new",
+        }),
+        trailing_mods_re=re.compile(r"\s*(?:throws\s+[\w,\s]+)?\s*\{?\s*$"),
+        access_spec_re=re.compile(r"(?!x)x"),  # Java has no standalone access-spec lines
+        macro_like_re=re.compile(r"(?!x)x"),
+        define_re=re.compile(r"(?!x)x"),
+        extern_c_re=re.compile(r"(?!x)x"),
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=True,
+        scope_operator=".",
+        base_keyword="super",
+        static_call_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        super_call_re=re.compile(r"\bsuper\.([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(
+            r"([A-Z][A-Za-z0-9_]+)\s*<[^>]*>\s+\w+|([A-Z][A-Za-z0-9_]+)\s+\w+"
+        ),
+        basic_skip_types=frozenset({
+            "int", "long", "short", "byte", "float", "double", "boolean", "char", "void",
+            "String", "Object", "Integer", "Long", "Double", "Float", "Boolean", "Byte",
+            "Short", "Character",
+        }),
+        block_keyword_re=re.compile(r"\b(?:class|interface|enum)\b"),
+        lambda_re=re.compile(r"->"),  # Java lambdas
+        namespace_sig_re=None,
+        init_list_re=None,
+        access_spec_names=frozenset(),
+        view_structural_kws=("class ", "interface ", "enum "),
+        view_modifier_kws=("abstract ", "static ", "final ", "synchronized "),
+        local_var_modifiers="final|static|volatile|transient",
+        verbatim_string_prefix=None,
+        raw_string_char=None,
+        range_for_re=re.compile(
+            r"for\s*\(\s*(\w+(?:<[^>]*>)?)\s+(\w+)\s*:\s*(\w+)"
+        ),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s*\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )