a

README.md

@@ -1,14 +1,105 @@
 ---
-title: C Cpp Inspector
-emoji: 📚
+title: C-Cpp-Inspector
+emoji: 🔍️©️/©️++💻
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: 5.12.0
+sdk_version: 4.7.1
 app_file: app.py
 pinned: false
-license: ecl-2.0
-short_description: C Cpp Inspector
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# C/C++ Syntax and Features Inspector
+This project analyzes C/C++ code to extract insights about syntax elements, memory management, and C++ specific features. The tool identifies primitive types, pointers, structs, control structures, memory operations, and C++ features like classes and templates, helping developers understand and improve their C/C++ code.
+
+## Developer
+
+Developed by Ramon Mayor Martins (2025)
+
+- Email: [email protected]
+- Homepage: https://rmayormartins.github.io/
+- Twitter: @rmayormartins
+- GitHub: https://github.com/rmayormartins
+- Space: https://huggingface.co/rmayormartins
+
+## Key Features
+
+### Basic Analysis
+- **Syntax Elements**:
+  - Detects primitive types and constants
+  - Identifies variable declarations
+  - Analyzes control structures (if/else, switch/case, loops)
+  - Tracks operators (arithmetic, logical, bitwise)
+
+### C-Specific Features
+- **Memory Management**:
+  - Tracks malloc/calloc/realloc usage
+  - Monitors memory freeing operations
+  - Analyzes memory operations (memcpy, memmove, etc.)
+- **Data Structures**:
+  - Identifies pointers and multiple pointers
+  - Detects structs, unions, and enums
+  - Analyzes arrays and typedefs
+
+### C++ Features
+- **OOP Analysis**:
+  - Classes and objects
+  - Templates and namespaces
+  - Inheritance and polymorphism
+  - Member access specifiers
+- **Modern C++**:
+  - STL usage detection
+  - Modern C++ features (auto, nullptr, etc.)
+  - References and operator overloading
+
+## Interface Features
+- Upload multiple ©️/©️++ files (.c, .cpp, .h, .hpp)
+- Results organized in categorized tabs:
+  - File Information
+  - Basic Elements
+  - Pointers and Structures
+  - Control Flow
+  - Operators
+  - Input/Output
+  - Memory Management
+  - C++ Features
+
+## How to Use
+1. Open the application interface
+2. Upload one or more C/C++ files
+3. Click "Analisar Arquivos" (Analyze Files)
+4. View detailed analysis in each category tab
+
+## Installation
+
+### Requirements
+- Python 3.7+
+- libclang
+- gradio
+
+### Local Development
+To run locally:
+
+```bash
+# Install libclang (Ubuntu/Debian)
+sudo apt-get install libclang-dev
+
+# Install Python dependencies
+pip install -r requirements.txt
+
+# Run the application
+python app.py
+```
+
+### Google Colab
+To run in Google Colab:
+
+```python
+!apt-get update
+!apt-get install -y libclang-dev
+!pip install libclang gradio
+```
+
+## License
+MIT License

app.py

@@ -0,0 +1,367 @@
+import gradio as gr
+from clang.cindex import Index, CursorKind, TypeKind
+from collections import Counter
+from typing import Dict, List
+import os
+
+class CPPSyntaxAnalyzer:
+    """C/C++-Inspector: Análise sintática e recursos específicos de C/C++"""
+
+    def __init__(self):
+        self.index = Index.create()
+
+    def analyze_syntax(self, code: str, filename: str) -> Dict[str, int]:
+        """Analisa elementos sintáticos e estruturais do código"""
+        results = Counter()
+
+        try:
+            with open(filename, 'w') as f:
+                f.write(code)
+
+            tu = self.index.parse(filename)
+            
+            def visit_node(node):
+                # Tipos primitivos
+                if node.kind == CursorKind.VAR_DECL:
+                    if node.type.kind in [TypeKind.INT, TypeKind.FLOAT, TypeKind.DOUBLE, 
+                                        TypeKind.CHAR_S, TypeKind.BOOL]:
+                        results["Tipos Primitivos"] += 1
+
+                # Ponteiros
+                if node.type.kind == TypeKind.POINTER:
+                    results["Ponteiros"] += 1
+                    # Ponteiros para ponteiros (ponteiros múltiplos)
+                    if node.type.get_pointee().kind == TypeKind.POINTER:
+                        results["Ponteiros Múltiplos"] += 1
+
+                # Structs
+                if node.kind == CursorKind.STRUCT_DECL:
+                    results["Structs"] += 1
+
+                # Unions
+                if node.kind == CursorKind.UNION_DECL:
+                    results["Unions"] += 1
+
+                # Enums
+                if node.kind == CursorKind.ENUM_DECL:
+                    results["Enums"] += 1
+
+                # Typedef
+                if node.kind == CursorKind.TYPEDEF_DECL:
+                    results["Typedefs"] += 1
+
+                # Arrays
+                if node.type.kind == TypeKind.CONSTANTARRAY:
+                    results["Arrays"] += 1
+
+                # Variáveis e Constantes
+                if node.kind == CursorKind.VAR_DECL:
+                    results["Variáveis Declaradas"] += 1
+                    if "const" in [token.spelling for token in node.get_tokens()]:
+                        results["Constantes"] += 1
+
+                # Estruturas de Controle
+                if node.kind == CursorKind.IF_STMT:
+                    results["If/Else"] += 1
+                elif node.kind == CursorKind.SWITCH_STMT:
+                    results["Switch/Case"] += 1
+                elif node.kind == CursorKind.FOR_STMT:
+                    results["For Loops"] += 1
+                elif node.kind == CursorKind.WHILE_STMT:
+                    results["While Loops"] += 1
+                elif node.kind == CursorKind.DO_STMT:
+                    results["Do-While Loops"] += 1
+
+                # Entrada/Saída
+                if node.kind == CursorKind.CALL_EXPR:
+                    func_name = node.spelling.lower()
+                    if func_name in ['printf', 'cout', 'puts', 'fprintf']:
+                        results["Funções de Saída"] += 1
+                    elif func_name in ['scanf', 'cin', 'gets', 'fscanf']:
+                        results["Funções de Entrada"] += 1
+
+                # Análise recursiva
+                for child in node.get_children():
+                    visit_node(child)
+
+            visit_node(tu.cursor)
+
+            # Análise de operadores e funções específicas via texto
+            code_text = code.lower()
+            
+            # Operadores
+            operators = {
+                "Aritméticos": ["+", "-", "*", "/", "%"],
+                "Comparação": ["==", "!=", ">", "<", ">=", "<="],
+                "Lógicos": ["&&", "||", "!"],
+                "Bit a Bit": ["&", "|", "^", "<<", ">>", "~"],
+                "Atribuição": ["+=", "-=", "*=", "/=", "&=", "|=", ">>=", "<<="],
+            }
+            for category, ops in operators.items():
+                results[category] = sum(code_text.count(op) for op in ops)
+
+            # Gerenciamento de Memória
+            memory_funcs = {
+                "malloc": code_text.count("malloc("),
+                "calloc": code_text.count("calloc("),
+                "realloc": code_text.count("realloc("),
+                "free": code_text.count("free("),
+                "new": code_text.count("new "),
+                "delete": code_text.count("delete "),
+                "delete[]": code_text.count("delete[]"),
+            }
+            results["Alocação Dinâmica (malloc/new)"] = memory_funcs["malloc"] + memory_funcs["calloc"] + memory_funcs["new"]
+            results["Liberação de Memória (free/delete)"] = memory_funcs["free"] + memory_funcs["delete"] + memory_funcs["delete[]"]
+            results["Realocação (realloc)"] = memory_funcs["realloc"]
+
+            # Manipulação de Memória
+            memory_ops = {
+                "memcpy": code_text.count("memcpy("),
+                "memmove": code_text.count("memmove("),
+                "memset": code_text.count("memset("),
+                "memcmp": code_text.count("memcmp("),
+            }
+            results["Operações de Memória"] = sum(memory_ops.values())
+
+        except Exception as e:
+            results["Erro"] = str(e)
+
+        return dict(results)
+
+    def analyze_cpp_features(self, code: str, filename: str) -> Dict[str, int]:
+        """Analisa recursos específicos de C++"""
+        results = Counter()
+
+        try:
+            with open(filename, 'w') as f:
+                f.write(code)
+
+            tu = self.index.parse(filename)
+
+            def visit_node(node):
+                # Classes
+                if node.kind == CursorKind.CLASS_DECL:
+                    results["Classes"] += 1
+
+                # Templates
+                if node.kind == CursorKind.CLASS_TEMPLATE:
+                    results["Templates"] += 1
+
+                # Namespace
+                if node.kind == CursorKind.NAMESPACE:
+                    results["Namespaces"] += 1
+
+                # Referências
+                if node.type.kind == TypeKind.LVALUEREFERENCE:
+                    results["Referências"] += 1
+
+                # Métodos
+                if node.kind == CursorKind.CXX_METHOD:
+                    results["Métodos"] += 1
+                    # Virtual
+                    if "virtual" in [token.spelling for token in node.get_tokens()]:
+                        results["Métodos Virtuais"] += 1
+
+                # Sobrecarga de Operadores
+                if node.kind == CursorKind.CXX_METHOD and node.spelling.startswith("operator"):
+                    results["Sobrecarga de Operadores"] += 1
+
+                # Membros e Encapsulamento
+                if node.kind == CursorKind.FIELD_DECL:
+                    results["Atributos"] += 1
+                    if node.access_specifier.name == "PRIVATE":
+                        results["Membros Private"] += 1
+                    elif node.access_specifier.name == "PROTECTED":
+                        results["Membros Protected"] += 1
+
+                # Herança
+                if node.kind == CursorKind.CXX_BASE_SPECIFIER:
+                    results["Herança"] += 1
+
+                # Análise recursiva
+                for child in node.get_children():
+                    visit_node(child)
+
+            visit_node(tu.cursor)
+
+            # Análise de recursos específicos via texto
+            code_text = code.lower()
+            
+            # STL e Recursos Modernos
+            stl_containers = ["vector", "list", "map", "set", "queue", "stack", "deque"]
+            results["Uso de STL"] = sum(code_text.count(container) for container in stl_containers)
+            
+            modern_features = ["auto", "nullptr", "constexpr", "static_assert", "decltype"]
+            results["Recursos C++ Moderno"] = sum(code_text.count(feature) for feature in modern_features)
+
+        except Exception as e:
+            results["Erro"] = str(e)
+
+        return dict(results)
+
+def process_files(files) -> List[Dict]:
+    """Processa múltiplos arquivos"""
+    analyzer = CPPSyntaxAnalyzer()
+    file_results = []
+
+    for file in files:
+        with open(file.name, 'r', encoding='utf-8') as f:
+            code = f.read()
+            
+        syntax_results = analyzer.analyze_syntax(code, file.name)
+        cpp_results = analyzer.analyze_cpp_features(code, file.name)
+        
+        combined_results = {**syntax_results, **cpp_results}
+        combined_results["Arquivo"] = file.name
+        file_results.append(combined_results)
+
+    return file_results
+def analyze_files(files):
+    """Analisa os arquivos e retorna os resultados separados por categoria"""
+    if not files:
+        return [], [], [], [], [], [], [], []
+        
+    results = process_files(files)
+    
+    # Separar resultados por categoria
+    file_info = [[result["Arquivo"]] for result in results]
+    
+    basic_elements = [[
+        result.get("Tipos Primitivos", 0),
+        result.get("Constantes", 0),
+        result.get("Variáveis Declaradas", 0)
+    ] for result in results]
+    
+    pointers_structs = [[
+        result.get("Ponteiros", 0),
+        result.get("Ponteiros Múltiplos", 0),
+        result.get("Arrays", 0),
+        result.get("Structs", 0),
+        result.get("Unions", 0),
+        result.get("Enums", 0),
+        result.get("Typedefs", 0)
+    ] for result in results]
+    
+    flow_control = [[
+        result.get("If/Else", 0),
+        result.get("Switch/Case", 0),
+        result.get("For Loops", 0),
+        result.get("While Loops", 0),
+        result.get("Do-While Loops", 0)
+    ] for result in results]
+    
+    operators = [[
+        result.get("Aritméticos", 0),
+        result.get("Comparação", 0),
+        result.get("Lógicos", 0),
+        result.get("Bit a Bit", 0),
+        result.get("Atribuição", 0)
+    ] for result in results]
+    
+    io_ops = [[
+        result.get("Funções de Entrada", 0),
+        result.get("Funções de Saída", 0)
+    ] for result in results]
+    
+    memory = [[
+        result.get("Alocação Dinâmica (malloc/new)", 0),
+        result.get("Liberação de Memória (free/delete)", 0),
+        result.get("Realocação (realloc)", 0),
+        result.get("Operações de Memória", 0)
+    ] for result in results]
+    
+    cpp_features = [[
+        result.get("Classes", 0),
+        result.get("Templates", 0),
+        result.get("Namespaces", 0),
+        result.get("Referências", 0),
+        result.get("Métodos", 0),
+        result.get("Métodos Virtuais", 0),
+        result.get("Sobrecarga de Operadores", 0),
+        result.get("Membros Private", 0),
+        result.get("Membros Protected", 0),
+        result.get("Herança", 0),
+        result.get("Uso de STL", 0),
+        result.get("Recursos C++ Moderno", 0)
+    ] for result in results]
+    
+    return (file_info, basic_elements, pointers_structs, flow_control, 
+            operators, io_ops, memory, cpp_features)
+
+# Interface Gradio
+with gr.Blocks(title="C/Cpp-Inspector") as demo:
+    gr.Markdown("# C/Cpp-Inspector: Code Analysis")
+    gr.Markdown("""
+    <p>Ramon Mayor Martins: <a href="https://rmayormartins.github.io/" target="_blank">Website</a> | <a href="https://huggingface.co/rmayormartins" target="_blank">Spaces</a> | <a href="https://github.com/rmayormartins" target="_blank">Github</a></p>
+    """)
+    gr.Markdown("Faça upload dos arquivos C/C++ para análise detalhada das estruturas e recursos da linguagem.")
+
+    with gr.Column():
+        file_input = gr.File(label="Arquivos C/C++", file_types=[".c", ".cpp", ".h", ".hpp"], file_count="multiple")
+        analyze_button = gr.Button("Analisar Arquivos")
+        
+        gr.Markdown("## Resultados da Análise ©️/©️++")
+        
+        with gr.Tabs():
+            with gr.TabItem("📁 Informações do Arquivo"):
+                output_file = gr.Dataframe(
+                    label="Arquivo",
+                    headers=["Arquivo"]
+                )
+            
+            with gr.TabItem("#️⃣ Elementos Básicos"):
+                output_basic = gr.Dataframe(
+                    label="Elementos Básicos",
+                    headers=["Tipos Primitivos", "Constantes", "Variáveis Declaradas"]
+                )
+            
+            with gr.TabItem("*️⃣ Ponteiros e Estruturas"):
+                output_pointers = gr.Dataframe(
+                    label="Ponteiros e Estruturas",
+                    headers=["Ponteiros", "Ponteiros Múltiplos", "Arrays", 
+                            "Structs", "Unions", "Enums", "Typedefs"]
+                )
+            
+            with gr.TabItem("🔄 Controle de Fluxo"):
+                output_flow = gr.Dataframe(
+                    label="Controle de Fluxo",
+                    headers=["If/Else", "Switch/Case", "For Loops", "While Loops", "Do-While Loops"]
+                )
+            
+            with gr.TabItem("🔣 Operadores"):
+                output_operators = gr.Dataframe(
+                    label="Operadores",
+                    headers=["Aritméticos", "Comparação", "Lógicos", "Bit a Bit", "Atribuição"]
+                )
+            
+            with gr.TabItem("↕️ Entrada/Saída"):
+                output_io = gr.Dataframe(
+                    label="Entrada/Saída",
+                    headers=["Funções de Entrada", "Funções de Saída"]
+                )
+            
+            with gr.TabItem("⏺️ Gerenciamento de Memória"):
+                output_memory = gr.Dataframe(
+                    label="Gerenciamento de Memória",
+                    headers=["Alocação Dinâmica (malloc/new)", "Liberação de Memória (free/delete)",
+                            "Realocação (realloc)", "Operações de Memória"]
+                )
+            
+            with gr.TabItem("⏭️ Recursos C++"):
+                output_cpp = gr.Dataframe(
+                    label="Recursos C++",
+                    headers=["Classes", "Templates", "Namespaces", "Referências",
+                            "Métodos", "Métodos Virtuais", "Sobrecarga de Operadores",
+                            "Membros Private", "Membros Protected", "Herança",
+                            "Uso de STL", "Recursos C++ Moderno"]
+                )
+
+        analyze_button.click(
+            fn=analyze_files,
+            inputs=file_input,
+            outputs=[output_file, output_basic, output_pointers, output_flow,
+                    output_operators, output_io, output_memory, output_cpp]
+        )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+libclang>=14.0.0
+