temp.txt

# def segment_code(file, symbols, max_lines):
#     """Segment code into smaller units."""
#     with open(file, "r") as f:
#         lines = f.readlines()

#     segments = []
#     current_segment = []
#     current_line_count = 0
#     last_end = 0

#     for symbol in symbols:
#         start = symbol.start_line - 1
#         end = symbol.end_line

#         if start > last_end:
#             current_segment.extend(lines[last_end:start])
#             current_line_count += start - last_end

#         if current_line_count + (end - start) > max_lines:
#             segment_file = os.path.join(OUTPUT_DIR, f"segment_{len(segments)}.c")
#             with open(segment_file, "w") as f:
#                 f.writelines(current_segment)
#             segments.append(Segment(segment_file, len(current_segment)))
#             current_segment = []
#             current_line_count = 0

#         current_segment.extend(lines[start:end])
#         current_line_count += end - start
#         last_end = end

#     if last_end < len(lines):
#         current_segment.extend(lines[last_end:])
#         segment_file = os.path.join(OUTPUT_DIR, f"segment_{len(segments)}.c")
#         with open(segment_file, "w") as f:
#             f.writelines(current_segment)
#         segments.append(Segment(segment_file, len(current_segment)))

#     print(f"Segmented code into {len(segments)} parts.")
#     return segments

# def preprocess_with_cpp(file):
#     """Preprocess a single C file using the C preprocessor."""
#     output_file = os.path.join(OUTPUT_DIR, f"preprocessed_{os.path.basename(file)}")
#     try:
#         subprocess.run(
#             ["gcc", "-E", file, "-o", output_file, "-std=c99"],
#             capture_output=True,
#             text=True,
#             check=True  # Raise an exception if the command fails
#         )
#     except subprocess.CalledProcessError as e:
#         raise Exception(f"C preprocessor failed for {file}: {e.stderr}") from e
#     print(f"Preprocessed file saved as {output_file}")
#     return output_file


# def translate_to_rust(c_code):
#     """Translates C code to Rust using Gemini API."""
#     try:
#         # Configure the Gemini API
#         genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
        
#         # Create the model instance
#         model = genai.GenerativeModel('gemini-pro')
        
#         # Create the system instruction prompt
#         prompt = f"""You are an expert programmer experienced in C and Rust conversion.
#         Translate the following C code to safe, idiomatic Rust code.
#         Include detailed comments explaining key changes.
        
#         Requirements:
#         1. Use proper ownership semantics
#         2. Convert pointers to Rust-safe constructs
#         3. Add proper error handling
#         4. Preserve original functionality
#         5. Add documentation comments
#         6. Since these are all segment which will be merged, do not expand any stray function calls 
#         7. return a rust file with all the other information as comments

#         C Code:
#         {c_code}
        
#         Rust Translation:"""
        
#         # Generate the response
#         response = model.generate_content(prompt)
#         return response.text
        
#     except Exception as e:
#         return f"// Translation failed: {str(e)}"