Topic - 【AI】通过多轮对话实现完整的python程序获取指定目录下c/c++代码的函数

通过如下多轮对话实现完整的python程序获取指定目录下c/c++代码的函数，无人工修正
```
1. python实现一个程序找出c语言代码的所有函数
2. 过滤掉c语言常用的关键词
3. 改成获取目录下所有c文件的
4. 去掉所有的中文
5. 函数名的显示宽度调大到30
6. c和cpp都支持
```

```python
import re
from pathlib import Path

# C/C++ keywords
C_KEYWORDS = {
    'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
    'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if',
    'int', 'long', 'register', 'return', 'short', 'signed', 'sizeof', 'static',
    'struct', 'switch', 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while',
    '_Alignas', '_Alignof', '_Atomic', '_Bool', '_Complex', '_Generic', '_Imaginary',
    '_Noreturn', '_Static_assert', '_Thread_local'
}

# C++ additional keywords
CPP_KEYWORDS = {
    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'atomic_cancel', 'atomic_commit', 
    'atomic_noexcept', 'auto', 'bitand', 'bitor', 'bool', 'break', 'case', 'catch', 
    'char', 'char8_t', 'char16_t', 'char32_t', 'class', 'compl', 'concept', 'const', 
    'consteval', 'constexpr', 'constinit', 'const_cast', 'continue', 'co_await', 'co_return', 
    'co_yield', 'decltype', 'default', 'delete', 'do', 'double', 'dynamic_cast', 'else', 
    'enum', 'explicit', 'export', 'extern', 'false', 'float', 'for', 'friend', 'goto', 'if', 
    'inline', 'int', 'long', 'mutable', 'namespace', 'new', 'noexcept', 'not', 'not_eq', 'nullptr', 
    'operator', 'or', 'or_eq', 'private', 'protected', 'public', 'reflexpr', 'register', 'reinterpret_cast', 
    'requires', 'return', 'short', 'signed', 'sizeof', 'static', 'static_assert', 'static_cast', 'struct', 
    'switch', 'synchronized', 'template', 'this', 'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 
    'typename', 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t', 'while', 'xor', 'xor_eq'
}

# Combine C and C++ keywords
ALL_KEYWORDS = C_KEYWORDS.union(CPP_KEYWORDS)

def find_functions_in_code(source_code: str, is_cpp: bool) -> list[tuple[str, str, int]]:
    """Find all function definitions in C/C++ code
    
    Args:
        source_code (str): Source code
        is_cpp (bool): True for C++, False for C
        
    Returns:
        list[tuple[str, str, int]]: List of functions (name, return_type, line_number)
    """
    code = remove_comments(source_code)
    
    # Adjust regex pattern for C++ (allow templates, namespaces, etc.)
    if is_cpp:
        function_pattern = re.compile(r'''
            (?:template\s*<[^>]*>\s*)?  # Optional template declaration
            ([\w\:\*&\s]+?)            # Return type (allow namespaces, pointers, references)
            \s*
            ([\w\:]+)                  # Function name (allow namespaces)
            \s*
            $([^)]*)$                # Parameter list
            \s*
            (?:const)?\s*              # Optional const qualifier
            \{                         # Function body start
        ''', re.VERBOSE | re.DOTALL)
    else:
        function_pattern = re.compile(r'''
            (\w+\s*[\*\s]*?)  # Return type
            \s+
            (\w+)             # Function name
            \s*
            $([^)]*)$       # Parameter list
            \s*
            \{                # Function body start
        ''', re.VERBOSE | re.DOTALL)
    
    functions = []
    
    for match in function_pattern.finditer(code):
        return_type = match.group(1).strip()
        function_name = match.group(2).strip()
        # Extract just the function name from namespaced names (C++)
        simple_name = function_name.split('::')[-1]
        start_pos = match.start()
        line_number = code[:start_pos].count('\n') + 1
        
        # Use ALL_KEYWORDS for C++ and C_KEYWORDS for C
        keyword_set = ALL_KEYWORDS if is_cpp else C_KEYWORDS
        
        if simple_name not in keyword_set:
            functions.append((function_name, return_type, line_number))
    
    return functions

def remove_comments(source_code: str) -> str:
    """Remove comments from C/C++ code"""
    # Remove line comments
    code = re.sub(r'//.*?$', '', source_code, flags=re.MULTILINE)
    # Remove block comments
    code = re.sub(r'/\*.*?\*/', '', code, flags=re.DOTALL)
    return code

def process_source_file(file_path: Path) -> list[tuple[str, str, int, Path]]:
    """Process a source file and return functions with file path info"""
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            content = file.read()
        
        # Determine file type based on extension
        is_cpp = file_path.suffix.lower() in {'.cpp', '.cxx', '.cc', '.c++', '.hpp', '.hxx', '.hh', '.h++'}
        
        functions = find_functions_in_code(content, is_cpp)
        return [(name, ret_type, line, file_path) for name, ret_type, line in functions]
    except UnicodeDecodeError:
        print(f"Error: File '{file_path}' is not UTF-8 encoded")
        return []
    except Exception as e:
        print(f"Error processing file '{file_path}': {e}")
        return []

def find_source_files(directory: Path) -> list[Path]:
    """Find all C/C++ source files in a directory recursively"""
    c_extensions = {'*.c', '*.h'}
    cpp_extensions = {'*.cpp', '*.cxx', '*.cc', '*.c++', '*.hpp', '*.hxx', '*.hh', '*.h++'}
    
    all_files = []
    for ext in c_extensions.union(cpp_extensions):
        all_files.extend(directory.rglob(ext))
    
    return all_files

def main():
    """Main function for command-line usage"""
    import argparse
    
    parser = argparse.ArgumentParser(description='Find functions in C/C++ source files')
    parser.add_argument('path', help='C/C++ source file or directory path')
    args = parser.parse_args()
    
    path = Path(args.path)
    
    if not path.exists():
        print(f"Error: Path '{path}' does not exist")
        return
    
    all_functions = []
    
    if path.is_file():
        ext = path.suffix.lower()
        if ext not in {'.c', '.h', '.cpp', '.cxx', '.cc', '.c++', '.hpp', '.hxx', '.hh', '.h++'}:
            print(f"Warning: File '{path}' may not be a C/C++ source file")
        all_functions = process_source_file(path)
    else:
        source_files = find_source_files(path)
        if not source_files:
            print(f"Error: No C/C++ files found in directory '{path}'")
            return
        
        print(f"Found {len(source_files)} source files in directory '{path}', analyzing...")
        
        for file in source_files:
            file_functions = process_source_file(file)
            all_functions.extend(file_functions)
    
    if not all_functions:
        print("No function definitions found")
    else:
        print(f"Total {len(all_functions)} functions found:")
        print("=" * 90)
        print(f"{'Function Name':<30} {'Return Type':<25} {'Line':<8} {'File Path'}")
        print("-" * 90)
        
        for name, ret_type, line, file_path in sorted(all_functions, key=lambda x: str(x[3])):
            print(f"{name:<30} {ret_type:<25} {line:<8} {file_path}")

if __name__ == "__main__":
    main()    
```

运行结果：
![1747840108366.png](/upload/image/20250521/20250521230828_D4BD621D3C2730E1D29396E47C237328.png)

	南柯	2023
	cxlove	1970
	vainner	1763
4	1000310428赵成帅	1718
5	XiaoWen	1710
6	1000380213洪伟焕	1701
7	weiben	1684
8	Jungle.Wei	1678
9	1100310131曾翔宇	1664
10	hongwh	1653