- New command: c_util edit <file> <start_line> <checksum1> [checksum2...] - Verifies all checksums before editing - Auto-learns indentation style from surrounding code - Applies correct indentation to new code block - Preserves preprocessor directives (no indentation) - Supports both tabs and spaces for indentation - Format: "line_num checksum: line_content" for show/description
1081 lines
35 KiB
Python
Executable File
1081 lines
35 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
c_util - C code navigation utility
|
|
Commands:
|
|
toc - Show table of contents for all files
|
|
description <names...> - Show selected items with comments
|
|
show <name1> [name2] - Show code for functions/structs/enums
|
|
edit <file> <line> <checksums> - Edit file with checksum verification
|
|
"""
|
|
|
|
import sys
|
|
import re
|
|
|
|
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'
|
|
}
|
|
|
|
CONTROL_FLOW = {'if', 'for', 'while', 'switch', 'return', 'else'}
|
|
|
|
|
|
def read_filelist(filename='filelist.txt'):
|
|
"""Read list of files to process."""
|
|
with open(filename, 'r') as f:
|
|
return [line.strip() for line in f if line.strip()]
|
|
|
|
|
|
def load_files(files):
|
|
"""Load contents of all files."""
|
|
contents = {}
|
|
for f in files:
|
|
try:
|
|
with open(f, 'r') as fd:
|
|
contents[f] = fd.read().splitlines()
|
|
except Exception as e:
|
|
print(f"Warning: could not read {f}: {e}", file=sys.stderr)
|
|
return contents
|
|
|
|
|
|
def preprocess_lines(lines):
|
|
"""
|
|
Preprocess lines:
|
|
- Remove preprocessor directives (#...)
|
|
- Remove comments (/* */ and //)
|
|
- Track pre_lines (comments before declarations)
|
|
Returns list of tuples: (original_line, is_code, pre_lines)
|
|
"""
|
|
result = []
|
|
multi_comment = False
|
|
pre_lines = []
|
|
|
|
for line in lines:
|
|
stripped = line.strip()
|
|
|
|
# Handle multi-line comments
|
|
if multi_comment:
|
|
if '*/' in line:
|
|
multi_comment = False
|
|
pre_lines.append(line)
|
|
result.append((line, False, []))
|
|
continue
|
|
|
|
# Start of multi-line comment
|
|
if '/*' in line:
|
|
end_pos = line.find('*/')
|
|
if end_pos == -1:
|
|
# Comment continues to next line
|
|
multi_comment = True
|
|
pre_lines.append(line)
|
|
result.append((line, False, []))
|
|
continue
|
|
else:
|
|
# Single-line block comment
|
|
pre_lines.append(line)
|
|
result.append((line, False, []))
|
|
continue
|
|
|
|
# Single-line comment
|
|
if stripped.startswith('//'):
|
|
pre_lines.append(line)
|
|
result.append((line, False, []))
|
|
continue
|
|
|
|
# Preprocessor directive - remove but don't add to pre_lines
|
|
if stripped.startswith('#'):
|
|
result.append((line, False, []))
|
|
continue
|
|
|
|
# Empty line - keep as separator but not code
|
|
if not stripped:
|
|
result.append((line, False, []))
|
|
continue
|
|
|
|
# This is actual code
|
|
current_pre = pre_lines[:]
|
|
pre_lines = []
|
|
result.append((line, True, current_pre))
|
|
|
|
return result
|
|
|
|
|
|
def compute_brace_levels(lines_info):
|
|
"""
|
|
Compute brace nesting level for each line.
|
|
Returns list of levels (level before processing the line).
|
|
"""
|
|
levels = []
|
|
brace_level = 0
|
|
|
|
for line, is_code, _ in lines_info:
|
|
levels.append(brace_level)
|
|
|
|
if not is_code:
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
|
|
# Skip preprocessor (already filtered but double-check)
|
|
if stripped.startswith('#'):
|
|
continue
|
|
|
|
# Skip extern "C" { blocks (C++ linkage)
|
|
if 'extern "C"' in stripped:
|
|
# Count braces in extern "C" line separately
|
|
if '{' in stripped:
|
|
# Don't count this brace as it opens/closes C linkage block
|
|
pass
|
|
continue
|
|
|
|
# Skip do { ... } while(0) - not real nesting
|
|
if stripped.startswith('do {'):
|
|
continue
|
|
if stripped.startswith('}') and 'while(0)' in stripped:
|
|
continue
|
|
|
|
# Count braces
|
|
brace_level += line.count('{') - line.count('}')
|
|
|
|
return levels
|
|
|
|
|
|
def extract_identifier_before_paren(line):
|
|
"""
|
|
Extract function name before first '('.
|
|
Returns (name, return_type) or (None, None) if invalid.
|
|
"""
|
|
paren_pos = line.find('(')
|
|
if paren_pos <= 0:
|
|
return None, None
|
|
|
|
before = line[:paren_pos].strip()
|
|
|
|
# Split into parts (handle pointers, qualifiers, etc.)
|
|
# e.g., "static int * func_name" -> ["static", "int", "*", "func_name"]
|
|
parts = before.split()
|
|
|
|
if not parts:
|
|
return None, None
|
|
|
|
# Last part should be function name
|
|
name = parts[-1].strip('*').strip()
|
|
|
|
# Check if it's a valid identifier
|
|
if not name.isidentifier():
|
|
return None, None
|
|
|
|
# Check if it's a keyword
|
|
if name in C_KEYWORDS or name in CONTROL_FLOW:
|
|
return None, None
|
|
|
|
# Return type is everything except name
|
|
ret_type = ' '.join(parts[:-1]) if len(parts) > 1 else 'void'
|
|
|
|
return name, ret_type
|
|
|
|
|
|
def find_matching_brace(lines_info, start_idx, start_level):
|
|
"""
|
|
Find line index of matching closing brace.
|
|
Starts from start_idx, looking for level to return to start_level.
|
|
"""
|
|
level = start_level
|
|
|
|
for i in range(start_idx, len(lines_info)):
|
|
line, is_code, _ = lines_info[i]
|
|
|
|
if not is_code:
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
|
|
# Skip preprocessor
|
|
if stripped.startswith('#'):
|
|
continue
|
|
|
|
# Skip do-while
|
|
if stripped.startswith('do {'):
|
|
continue
|
|
if stripped.startswith('}') and 'while(0)' in stripped:
|
|
continue
|
|
|
|
# Check current level before this line
|
|
if level == start_level and i > start_idx and '}' in line:
|
|
return i
|
|
|
|
# Update level
|
|
level += line.count('{') - line.count('}')
|
|
|
|
return len(lines_info) - 1
|
|
|
|
|
|
def extract_declarations(lines):
|
|
"""
|
|
Extract all function, struct, and enum declarations.
|
|
Returns (functions, structs, enums).
|
|
"""
|
|
functions = []
|
|
structs = []
|
|
enums = []
|
|
|
|
# Preprocess
|
|
lines_info = preprocess_lines(lines)
|
|
|
|
# Compute brace levels
|
|
brace_levels = compute_brace_levels(lines_info)
|
|
|
|
i = 0
|
|
n = len(lines_info)
|
|
|
|
while i < n:
|
|
line, is_code, pre_lines = lines_info[i]
|
|
|
|
if not is_code:
|
|
i += 1
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
level = brace_levels[i]
|
|
|
|
# Only process declarations at level 0
|
|
if level != 0:
|
|
i += 1
|
|
continue
|
|
|
|
# Check for typedef struct/enum/union
|
|
if stripped.startswith('typedef struct'):
|
|
name, decl_end = parse_typedef_struct(lines_info, i)
|
|
if name:
|
|
structs.append({
|
|
'name': name,
|
|
'pre': pre_lines,
|
|
'start': i,
|
|
'end': decl_end,
|
|
'line_count': decl_end - i + 1
|
|
})
|
|
i = decl_end + 1
|
|
continue
|
|
|
|
if stripped.startswith('typedef enum'):
|
|
name, decl_end = parse_typedef_enum(lines_info, i)
|
|
if name:
|
|
enums.append({
|
|
'name': name,
|
|
'pre': pre_lines,
|
|
'start': i,
|
|
'end': decl_end,
|
|
'line_count': decl_end - i + 1
|
|
})
|
|
i = decl_end + 1
|
|
continue
|
|
|
|
# Check for simple struct/enum declarations
|
|
if stripped.startswith('struct ') and '{' in stripped:
|
|
name, decl_end = parse_simple_struct(lines_info, i)
|
|
if name:
|
|
structs.append({
|
|
'name': name,
|
|
'pre': pre_lines,
|
|
'start': i,
|
|
'end': decl_end,
|
|
'line_count': decl_end - i + 1
|
|
})
|
|
i = decl_end + 1
|
|
continue
|
|
|
|
if stripped.startswith('enum ') and '{' in stripped:
|
|
name, decl_end = parse_simple_enum(lines_info, i)
|
|
if name:
|
|
enums.append({
|
|
'name': name,
|
|
'pre': pre_lines,
|
|
'start': i,
|
|
'end': decl_end,
|
|
'line_count': decl_end - i + 1
|
|
})
|
|
i = decl_end + 1
|
|
continue
|
|
|
|
# Check for function declarations
|
|
if '(' in stripped:
|
|
func_info = parse_function(lines_info, i)
|
|
if func_info:
|
|
functions.append(func_info)
|
|
i = func_info['end'] + 1
|
|
continue
|
|
|
|
i += 1
|
|
|
|
return functions, structs, enums
|
|
|
|
|
|
def parse_typedef_struct(lines_info, start_idx):
|
|
"""Parse typedef struct { ... } name;"""
|
|
# Collect lines until we have complete declaration
|
|
decl_lines = []
|
|
brace_count = 0
|
|
|
|
for i in range(start_idx, len(lines_info)):
|
|
line, is_code, _ = lines_info[i]
|
|
decl_lines.append(line)
|
|
|
|
if not is_code:
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
|
|
# Count braces (skip do-while)
|
|
if not stripped.startswith('do {'):
|
|
if not (stripped.startswith('}') and 'while(0)' in stripped):
|
|
brace_count += line.count('{') - line.count('}')
|
|
|
|
# If we've closed all braces and found semicolon, we're done
|
|
if brace_count == 0 and stripped.endswith(';'):
|
|
# Extract name from "} name;"
|
|
decl_text = ' '.join([l.strip() for l in decl_lines])
|
|
close_brace = decl_text.rfind('}')
|
|
semi = decl_text.find(';', close_brace)
|
|
|
|
if close_brace > 0 and semi > close_brace:
|
|
name = decl_text[close_brace + 1:semi].strip()
|
|
return name, i
|
|
return None, i
|
|
|
|
return None, len(lines_info) - 1
|
|
|
|
|
|
def parse_typedef_enum(lines_info, start_idx):
|
|
"""Parse typedef enum { ... } name;"""
|
|
# Same logic as typedef struct
|
|
decl_lines = []
|
|
brace_count = 0
|
|
|
|
for i in range(start_idx, len(lines_info)):
|
|
line, is_code, _ = lines_info[i]
|
|
decl_lines.append(line)
|
|
|
|
if not is_code:
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
|
|
if not stripped.startswith('do {'):
|
|
if not (stripped.startswith('}') and 'while(0)' in stripped):
|
|
brace_count += line.count('{') - line.count('}')
|
|
|
|
if brace_count == 0 and stripped.endswith(';'):
|
|
decl_text = ' '.join([l.strip() for l in decl_lines])
|
|
close_brace = decl_text.rfind('}')
|
|
semi = decl_text.find(';', close_brace)
|
|
|
|
if close_brace > 0 and semi > close_brace:
|
|
name = decl_text[close_brace + 1:semi].strip()
|
|
return name, i
|
|
return None, i
|
|
|
|
return None, len(lines_info) - 1
|
|
|
|
|
|
def parse_simple_struct(lines_info, start_idx):
|
|
"""Parse struct name { ... };"""
|
|
line, is_code, _ = lines_info[start_idx]
|
|
stripped = line.strip()
|
|
|
|
# Extract name: "struct name {"
|
|
match = re.match(r'struct\s+(\w+)\s*\{', stripped)
|
|
if not match:
|
|
return None, start_idx
|
|
|
|
name = match.group(1)
|
|
|
|
# Find closing brace
|
|
brace_count = 1
|
|
for i in range(start_idx + 1, len(lines_info)):
|
|
line, is_code, _ = lines_info[i]
|
|
|
|
if not is_code:
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
|
|
if not stripped.startswith('do {'):
|
|
if not (stripped.startswith('}') and 'while(0)' in stripped):
|
|
brace_count += line.count('{') - line.count('}')
|
|
|
|
if brace_count == 0:
|
|
return name, i
|
|
|
|
return name, len(lines_info) - 1
|
|
|
|
|
|
def parse_simple_enum(lines_info, start_idx):
|
|
"""Parse enum name { ... };"""
|
|
line, is_code, _ = lines_info[start_idx]
|
|
stripped = line.strip()
|
|
|
|
# Extract name: "enum name {"
|
|
match = re.match(r'enum\s+(\w+)\s*\{', stripped)
|
|
if not match:
|
|
return None, start_idx
|
|
|
|
name = match.group(1)
|
|
|
|
# Find closing brace
|
|
brace_count = 1
|
|
for i in range(start_idx + 1, len(lines_info)):
|
|
line, is_code, _ = lines_info[i]
|
|
|
|
if not is_code:
|
|
continue
|
|
|
|
stripped = line.strip()
|
|
|
|
if not stripped.startswith('do {'):
|
|
if not (stripped.startswith('}') and 'while(0)' in stripped):
|
|
brace_count += line.count('{') - line.count('}')
|
|
|
|
if brace_count == 0:
|
|
return name, i
|
|
|
|
return name, len(lines_info) - 1
|
|
|
|
|
|
def parse_function(lines_info, start_idx):
|
|
"""Parse function declaration at level 0."""
|
|
line, is_code, pre_lines = lines_info[start_idx]
|
|
stripped = line.strip()
|
|
|
|
# Extract function name
|
|
name, ret_type = extract_identifier_before_paren(stripped)
|
|
|
|
if not name:
|
|
return None
|
|
|
|
# Check if this is a forward declaration (ends with ;)
|
|
if stripped.endswith(';'):
|
|
return None
|
|
|
|
# Find opening brace - function body must start with {
|
|
# Check current line and next line only
|
|
decl_end = start_idx
|
|
found_brace = False
|
|
|
|
# Check current line first - look for { after )
|
|
paren_end = stripped.rfind(')')
|
|
if paren_end > 0:
|
|
after_paren = stripped[paren_end:]
|
|
if '{' in after_paren:
|
|
decl_end = start_idx
|
|
found_brace = True
|
|
|
|
# If not found, check next few lines (up to 3) for {
|
|
# But stop if we encounter ; (end of prototype)
|
|
if not found_brace:
|
|
for offset in range(1, 4): # Check next 3 lines
|
|
if start_idx + offset >= len(lines_info):
|
|
break
|
|
|
|
check_line, check_is_code, _ = lines_info[start_idx + offset]
|
|
if not check_is_code:
|
|
continue
|
|
|
|
check_stripped = check_line.strip()
|
|
|
|
# If we hit a semicolon, this is a prototype, not a definition
|
|
if check_stripped.endswith(';'):
|
|
return None
|
|
|
|
# If we found opening brace, this is the function body
|
|
# Check if '{' is present in the line (not necessarily at start due to formatting)
|
|
if '{' in check_line:
|
|
decl_end = start_idx + offset
|
|
found_brace = True
|
|
break
|
|
|
|
if not found_brace:
|
|
# No body - probably forward declaration or macro, skip
|
|
return None
|
|
|
|
# Find closing brace
|
|
closing = find_matching_brace(lines_info, decl_end + 1, 0)
|
|
|
|
# Extract arguments - need to collect all lines from start to decl_end
|
|
# to handle multi-line function signatures
|
|
sig_lines = []
|
|
for idx in range(start_idx, decl_end + 1):
|
|
l, is_code, _ = lines_info[idx]
|
|
if is_code:
|
|
sig_lines.append(l)
|
|
|
|
sig_text = ' '.join(sig_lines)
|
|
paren_start = sig_text.find('(')
|
|
paren_end = sig_text.rfind(')')
|
|
if paren_start > 0 and paren_end > paren_start:
|
|
args = sig_text[paren_start + 1:paren_end].strip()
|
|
else:
|
|
args = ''
|
|
|
|
return {
|
|
'type': 'function',
|
|
'name': name,
|
|
'args': args,
|
|
'ret': ret_type,
|
|
'pre': pre_lines,
|
|
'start': start_idx,
|
|
'end': closing,
|
|
'decl_end': decl_end, # Store the line with opening brace
|
|
'line_count': closing - start_idx + 1
|
|
}
|
|
|
|
|
|
def line_checksum(line):
|
|
"""Calculate checksum: sum of all character codes modulo 256, as 2 hex digits."""
|
|
checksum = sum(ord(c) for c in line) % 256
|
|
return f"{checksum:02X}"
|
|
|
|
|
|
def autolearn_indentation(lines, context_start=0, context_end=None):
|
|
"""
|
|
Analyze indentation style in the file.
|
|
|
|
Returns dict with:
|
|
- indent_char: '\t' or ' '
|
|
- indent_size: number of spaces per level (for spaces) or 1 (for tabs)
|
|
- base_indent: base indentation string for the context
|
|
"""
|
|
if context_end is None:
|
|
context_end = len(lines)
|
|
|
|
# Count tab vs space indented lines
|
|
tab_lines = 0
|
|
space_lines = 0
|
|
space_counts = []
|
|
|
|
for i in range(context_start, min(context_end, len(lines))):
|
|
line = lines[i]
|
|
if not line.strip():
|
|
continue
|
|
|
|
leading = line[:len(line) - len(line.lstrip())]
|
|
|
|
if '\t' in leading:
|
|
tab_lines += 1
|
|
elif ' ' in leading:
|
|
space_lines += 1
|
|
# Count leading spaces
|
|
space_count = len(leading)
|
|
if space_count > 0:
|
|
space_counts.append(space_count)
|
|
|
|
# Determine indent character
|
|
if tab_lines > space_lines:
|
|
indent_char = '\t'
|
|
indent_size = 1
|
|
else:
|
|
indent_char = ' '
|
|
# Calculate most common indent size (GCD of space counts)
|
|
if space_counts:
|
|
def gcd(a, b):
|
|
while b:
|
|
a, b = b, a % b
|
|
return a
|
|
|
|
indent_size = space_counts[0]
|
|
for count in space_counts[1:]:
|
|
indent_size = gcd(indent_size, count)
|
|
if indent_size == 1:
|
|
break
|
|
# Default to 4 if we couldn't determine
|
|
if indent_size < 2:
|
|
indent_size = 4
|
|
else:
|
|
indent_size = 4
|
|
|
|
return {
|
|
'indent_char': indent_char,
|
|
'indent_size': indent_size,
|
|
'indent_str': indent_char * indent_size if indent_char == ' ' else '\t'
|
|
}
|
|
|
|
|
|
def normalize_whitespace(text):
|
|
"""Normalize whitespace: replace multiple spaces/newlines with single space."""
|
|
# Replace all whitespace (spaces, tabs, newlines) with single space
|
|
text = re.sub(r'\s+', ' ', text)
|
|
# Strip leading/trailing whitespace
|
|
return text.strip()
|
|
|
|
|
|
def get_function_signature(lines, func):
|
|
"""Get normalized function signature (like prototype)."""
|
|
# Get all lines from start to the line with opening brace
|
|
start = func['start']
|
|
end = func.get('decl_end', func['start']) # We need to track decl_end in parse_function
|
|
|
|
# Collect signature lines
|
|
sig_lines = []
|
|
for i in range(start, min(end + 1, len(lines))):
|
|
line = lines[i]
|
|
# Remove comments
|
|
if '//' in line:
|
|
line = line[:line.index('//')]
|
|
sig_lines.append(line)
|
|
|
|
# Join and normalize
|
|
sig = ' '.join(sig_lines)
|
|
sig = normalize_whitespace(sig)
|
|
|
|
# Remove the opening brace if present
|
|
if '{' in sig:
|
|
sig = sig[:sig.index('{')].strip()
|
|
|
|
# Ensure it ends with semicolon
|
|
if not sig.endswith(';'):
|
|
sig += ';'
|
|
|
|
return sig
|
|
|
|
|
|
def get_declaration_text(lines, decl, include_comments=False):
|
|
"""Get normalized declaration text for struct/enum."""
|
|
start = decl['start']
|
|
end = decl['end']
|
|
|
|
# Collect all lines
|
|
decl_lines = []
|
|
for i in range(start, min(end + 1, len(lines))):
|
|
line = lines[i]
|
|
if not include_comments:
|
|
# Remove comments
|
|
if '//' in line:
|
|
line = line[:line.index('//')]
|
|
decl_lines.append(line)
|
|
|
|
if include_comments:
|
|
# Normalize: one tab indent, remove empty lines, normalize whitespace
|
|
result_lines = []
|
|
for line in decl_lines:
|
|
# Skip empty lines
|
|
if not line.strip():
|
|
continue
|
|
# Normalize whitespace and use one tab for indentation
|
|
normalized = normalize_whitespace(line)
|
|
if normalized:
|
|
result_lines.append('\t' + normalized)
|
|
return '\n'.join(result_lines)
|
|
else:
|
|
# Join and normalize for toc mode
|
|
text = ' '.join(decl_lines)
|
|
text = normalize_whitespace(text)
|
|
return text
|
|
|
|
|
|
def get_function_comments(pre_lines):
|
|
"""Extract function comments from pre_lines.
|
|
|
|
Returns:
|
|
- Last /* */ block if found (including single-line /* */)
|
|
- Or consecutive // lines (without empty lines or non-comment lines)
|
|
- Empty string if no suitable comments
|
|
"""
|
|
if not pre_lines:
|
|
return ""
|
|
|
|
# Look for last /* */ block
|
|
last_block_comment = ""
|
|
in_block = False
|
|
block_start = -1
|
|
|
|
for i, line in enumerate(pre_lines):
|
|
stripped = line.strip()
|
|
if stripped.startswith('/*'):
|
|
# Check if it's a single-line comment /* ... */
|
|
if stripped.endswith('*/'):
|
|
# Single-line block comment
|
|
last_block_comment = line
|
|
else:
|
|
# Start of multi-line block comment
|
|
in_block = True
|
|
block_start = i
|
|
elif in_block and stripped.endswith('*/'):
|
|
in_block = False
|
|
# Extract the block
|
|
block_lines = pre_lines[block_start:i+1]
|
|
last_block_comment = '\n'.join(block_lines)
|
|
elif stripped.startswith('*/'):
|
|
in_block = False
|
|
|
|
if last_block_comment:
|
|
return last_block_comment
|
|
|
|
# Look for consecutive // lines (from the end, backwards)
|
|
comment_lines = []
|
|
for line in reversed(pre_lines):
|
|
stripped = line.strip()
|
|
if stripped.startswith('//'):
|
|
comment_lines.insert(0, stripped)
|
|
elif not stripped: # Skip empty lines
|
|
continue
|
|
else: # Non-comment line breaks the sequence
|
|
break
|
|
|
|
return '\n'.join(comment_lines) if comment_lines else ""
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) < 2:
|
|
print("Usage: c_util toc | description <name1> [name2] ... | show <name1> [name2] ... | edit <file> <line> <checksums> ...")
|
|
sys.exit(1)
|
|
|
|
cmd = sys.argv[1]
|
|
|
|
files = read_filelist()
|
|
contents = load_files(files)
|
|
|
|
# Parse all files
|
|
project_functions = {}
|
|
project_structs = {}
|
|
project_enums = {}
|
|
|
|
for f, lines in contents.items():
|
|
funcs, strs, enums = extract_declarations(lines)
|
|
project_functions[f] = funcs
|
|
project_structs[f] = strs
|
|
project_enums[f] = enums
|
|
|
|
if cmd == 'toc':
|
|
first_file = True
|
|
for f in files:
|
|
if f not in contents:
|
|
continue
|
|
|
|
# Get all declarations for this file
|
|
declarations = []
|
|
|
|
# Add functions
|
|
for func in project_functions.get(f, []):
|
|
sig = get_function_signature(contents[f], func)
|
|
declarations.append((func['start'], func['end'], sig))
|
|
|
|
# Add structs
|
|
for s in project_structs.get(f, []):
|
|
text = get_declaration_text(contents[f], s)
|
|
declarations.append((s['start'], s['end'], text))
|
|
|
|
# Add enums
|
|
for e in project_enums.get(f, []):
|
|
text = get_declaration_text(contents[f], e)
|
|
declarations.append((e['start'], e['end'], text))
|
|
|
|
if not declarations:
|
|
continue
|
|
|
|
# Sort by line number
|
|
declarations.sort(key=lambda x: x[0])
|
|
|
|
# Print empty line between files (except before first)
|
|
if not first_file:
|
|
print()
|
|
first_file = False
|
|
|
|
# Print filename header
|
|
print(f"{f}:")
|
|
|
|
# Print in new format
|
|
for start, end, text in declarations:
|
|
print(f"[{start + 1}-{end + 1}] {text}")
|
|
|
|
elif cmd == 'description':
|
|
# Get list of names to look for
|
|
if len(sys.argv) < 3:
|
|
print("Usage: c_util description <name1> [name2] ...")
|
|
sys.exit(1)
|
|
|
|
target_names = set(sys.argv[2:])
|
|
first_file = True
|
|
|
|
for f in files:
|
|
if f not in contents:
|
|
continue
|
|
|
|
# Collect all matching declarations with full info
|
|
declarations = []
|
|
|
|
# Check functions
|
|
for func in project_functions.get(f, []):
|
|
if func['name'] in target_names:
|
|
# Get signature
|
|
sig = get_function_signature(contents[f], func)
|
|
# Get comments
|
|
comments = get_function_comments(func['pre'])
|
|
declarations.append((func['start'], func['end'], 'function', sig, comments))
|
|
|
|
# Check structs
|
|
for s in project_structs.get(f, []):
|
|
if s['name'] in target_names:
|
|
# Get full text with formatting and comments
|
|
text = get_declaration_text(contents[f], s, include_comments=True)
|
|
declarations.append((s['start'], s['end'], 'struct', s['name'], text))
|
|
|
|
# Check enums
|
|
for e in project_enums.get(f, []):
|
|
if e['name'] in target_names:
|
|
# Get full text with formatting and comments
|
|
text = get_declaration_text(contents[f], e, include_comments=True)
|
|
declarations.append((e['start'], e['end'], 'enum', e['name'], text))
|
|
|
|
if not declarations:
|
|
continue
|
|
|
|
# Sort by line number
|
|
declarations.sort(key=lambda x: x[0])
|
|
|
|
# Print empty line between files (except before first)
|
|
if not first_file:
|
|
print()
|
|
first_file = False
|
|
|
|
# Print filename header
|
|
print(f"{f}:")
|
|
|
|
# Print declarations with full formatting
|
|
for start, end, decl_type, content, extra in declarations:
|
|
if decl_type == 'function':
|
|
# Print comments first if any (without line numbers)
|
|
if extra:
|
|
print(extra)
|
|
# Print function signature with line number and checksum
|
|
lines = contents[f]
|
|
for line_idx in range(start, end + 1):
|
|
if line_idx < len(lines):
|
|
line = lines[line_idx]
|
|
line_num = line_idx + 1
|
|
checksum = line_checksum(line)
|
|
print(f"{line_num} {checksum}: {line}")
|
|
else:
|
|
# struct or enum - print with line numbers and checksums
|
|
lines = contents[f]
|
|
for line_idx in range(start, end + 1):
|
|
if line_idx < len(lines):
|
|
line = lines[line_idx]
|
|
line_num = line_idx + 1
|
|
checksum = line_checksum(line)
|
|
print(f"{line_num} {checksum}: {line}")
|
|
|
|
elif cmd == 'show':
|
|
if len(sys.argv) < 3:
|
|
print("Usage: c_util show <name1> [name2] ...")
|
|
sys.exit(1)
|
|
|
|
target_names = set(sys.argv[2:])
|
|
first_file = True
|
|
found_any = False
|
|
|
|
for f in files:
|
|
if f not in contents:
|
|
continue
|
|
|
|
# Collect all matching items
|
|
items = []
|
|
|
|
# Check functions
|
|
for func in project_functions.get(f, []):
|
|
if func['name'] in target_names:
|
|
items.append(('function', func))
|
|
found_any = True
|
|
|
|
# Check structs
|
|
for s in project_structs.get(f, []):
|
|
if s['name'] in target_names:
|
|
items.append(('struct', s))
|
|
found_any = True
|
|
|
|
# Check enums
|
|
for e in project_enums.get(f, []):
|
|
if e['name'] in target_names:
|
|
items.append(('enum', e))
|
|
found_any = True
|
|
|
|
if not items:
|
|
continue
|
|
|
|
# Sort by line number
|
|
items.sort(key=lambda x: x[1]['start'])
|
|
|
|
# Print empty line between files (except before first)
|
|
if not first_file:
|
|
print()
|
|
first_file = False
|
|
|
|
# Print filename header
|
|
print(f"{f}:")
|
|
|
|
# Print items with line numbers and checksums
|
|
for item_type, item in items:
|
|
lines = contents[f]
|
|
start = item['start']
|
|
end = item['end']
|
|
|
|
# Print pre lines (comments) without line numbers
|
|
pre = item['pre']
|
|
if pre:
|
|
for pre_line in pre:
|
|
print(pre_line)
|
|
|
|
# Print body with line numbers and checksums
|
|
for line_idx in range(start, end + 1):
|
|
if line_idx < len(lines):
|
|
line = lines[line_idx]
|
|
line_num = line_idx + 1
|
|
checksum = line_checksum(line)
|
|
print(f"{line_num} {checksum}: {line}")
|
|
|
|
if not found_any:
|
|
print("Not found")
|
|
sys.exit(1)
|
|
|
|
elif cmd == 'edit':
|
|
# Format: c_util edit path/file.c start_line checksum1 [checksum2 ...] <<'EOF'
|
|
if len(sys.argv) < 5:
|
|
print("Usage: c_util edit <file> <start_line> <checksum1> [checksum2 ...]")
|
|
print("Then provide new code block via stdin or heredoc")
|
|
sys.exit(1)
|
|
|
|
file_path = sys.argv[2]
|
|
|
|
# Load the file if not already loaded
|
|
if file_path not in contents:
|
|
try:
|
|
with open(file_path, 'r') as f:
|
|
contents[file_path] = f.read().splitlines()
|
|
except Exception as e:
|
|
print(f"Error reading file {file_path}: {e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
file_lines = contents[file_path]
|
|
|
|
try:
|
|
start_line = int(sys.argv[3])
|
|
except ValueError:
|
|
print(f"Invalid line number: {sys.argv[3]}")
|
|
sys.exit(1)
|
|
|
|
# Get expected checksums
|
|
expected_checksums = []
|
|
for checksum_str in sys.argv[4:]:
|
|
try:
|
|
expected_checksums.append(int(checksum_str, 16))
|
|
except ValueError:
|
|
print(f"Invalid checksum format: {checksum_str}")
|
|
sys.exit(1)
|
|
|
|
num_lines_to_replace = len(expected_checksums)
|
|
|
|
# Verify line numbers are valid
|
|
if start_line < 1 or start_line > len(file_lines):
|
|
print(f"Line number {start_line} out of range (1-{len(file_lines)})")
|
|
sys.exit(1)
|
|
|
|
if start_line + num_lines_to_replace - 1 > len(file_lines):
|
|
print(f"Block extends beyond end of file")
|
|
sys.exit(1)
|
|
|
|
# Verify checksums
|
|
actual_checksums = []
|
|
for i in range(num_lines_to_replace):
|
|
line_idx = start_line - 1 + i
|
|
actual_checksum = sum(ord(c) for c in file_lines[line_idx]) % 256
|
|
actual_checksums.append(actual_checksum)
|
|
expected = expected_checksums[i]
|
|
if actual_checksum != expected:
|
|
print(f"Checksum mismatch at line {line_idx + 1}:")
|
|
print(f" Expected: {expected:02X}")
|
|
print(f" Actual: {actual_checksum:02X}")
|
|
print(f" Line: {repr(file_lines[line_idx])}")
|
|
sys.exit(1)
|
|
|
|
# Read new code from stdin
|
|
print("Reading new code block from stdin...", file=sys.stderr)
|
|
new_code_lines = sys.stdin.read().splitlines()
|
|
|
|
# Determine indentation style from file
|
|
indent_info = autolearn_indentation(file_lines, max(0, start_line - 10), min(len(file_lines), start_line + num_lines_to_replace + 10))
|
|
|
|
# Calculate base indentation from the first line being replaced
|
|
first_old_line = file_lines[start_line - 1]
|
|
base_indent = first_old_line[:len(first_old_line) - len(first_old_line.lstrip())]
|
|
|
|
# Determine indentation level from surrounding code
|
|
# Count braces before the replacement block
|
|
brace_level = 0
|
|
for i in range(max(0, start_line - 20), start_line - 1):
|
|
line = file_lines[i]
|
|
# Skip preprocessor and comments
|
|
stripped = line.strip()
|
|
if stripped.startswith('#'):
|
|
continue
|
|
# Count braces (simple approach)
|
|
brace_level += line.count('{') - line.count('}')
|
|
|
|
# Apply indentation to new code
|
|
indented_new_lines = []
|
|
current_level = brace_level
|
|
|
|
for i, line in enumerate(new_code_lines):
|
|
stripped = line.strip()
|
|
|
|
# Empty line - keep as is
|
|
if not stripped:
|
|
indented_new_lines.append('')
|
|
continue
|
|
|
|
# Preprocessor directive - no indentation
|
|
if stripped.startswith('#'):
|
|
indented_new_lines.append(stripped)
|
|
continue
|
|
|
|
# Check for closing brace - reduce level before this line
|
|
if stripped.startswith('}'):
|
|
current_level -= 1
|
|
|
|
# Calculate indentation
|
|
if indent_info['indent_char'] == '\t':
|
|
indent = '\t' * current_level
|
|
else:
|
|
indent = ' ' * (indent_info['indent_size'] * current_level)
|
|
|
|
indented_new_lines.append(indent + stripped)
|
|
|
|
# Check for opening brace - increase level for next lines
|
|
if stripped.endswith('{'):
|
|
current_level += 1
|
|
|
|
# Replace the block
|
|
start_idx = start_line - 1
|
|
end_idx = start_idx + num_lines_to_replace
|
|
new_file_lines = file_lines[:start_idx] + indented_new_lines + file_lines[end_idx:]
|
|
|
|
# Write back to file
|
|
try:
|
|
with open(file_path, 'w') as f:
|
|
f.write('\n'.join(new_file_lines))
|
|
if new_file_lines and not new_file_lines[-1].endswith('\n'):
|
|
f.write('\n')
|
|
print(f"Successfully edited {file_path}")
|
|
print(f"Replaced {num_lines_to_replace} lines with {len(indented_new_lines)} lines")
|
|
except Exception as e:
|
|
print(f"Error writing file {file_path}: {e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
else:
|
|
print("Unknown command")
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|