Spaces:
Running
Running
| 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() |