simple_breakpoint.py

"""
Simple example demonstrating basic debugging workflow
"""

import sys
import os

# Add parent directory to path to import src module
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from src.debugger import AIDebugger
import json


def main():
    """
    Example: Basic debugging workflow
    
    This example shows how to:
    1. Create a debugging session
    2. Set breakpoints
    3. Run the program
    4. Step through code
    5. Inspect variables
    6. Get call stack
    7. Close the session
    """
    
    # Initialize the debugger
    debugger = AIDebugger()
    
    # Replace with your program path
    program_path = "./my_program"
    
    print("=" * 60)
    print("C/C++ AI Debugger - Basic Example")
    print("=" * 60)
    
    try:
        # Step 1: Create a debugging session
        print("\n[1] Creating debug session...")
        result = debugger.execute_command(json.dumps({
            'action': 'create_session',
            'params': {
                'program_path': program_path,
                'debugger_type': 'auto'  # Auto-detect GDB or LLDB
            }
        }))
        
        response = json.loads(result)
        if not response['success']:
            print(f"Error: {response['error']}")
            return
        
        session_id = response['result']['session_id']
        print(f"✓ Session created: {session_id}")
        
        # Step 2: Set a breakpoint at main function
        print("\n[2] Setting breakpoint at main()...")
        result = debugger.execute_command(json.dumps({
            'action': 'set_breakpoint',
            'params': {
                'session_id': session_id,
                'location': 'main'
            }
        }))
        
        response = json.loads(result)
        if response['success']:
            print(f"✓ Breakpoint set: {response['result']}")
        else:
            print(f"✗ Failed to set breakpoint: {response['error']}")
        
        # Step 3: Run the program
        print("\n[3] Running program...")
        result = debugger.execute_command(json.dumps({
            'action': 'run',
            'params': {
                'session_id': session_id
            }
        }))
        
        response = json.loads(result)
        if response['success']:
            print(f"✓ Program running, state: {response['result']['state']}")
        else:
            print(f"✗ Failed to run: {response['error']}")
        
        # Step 4: Get current location
        print("\n[4] Getting current location...")
        result = debugger.execute_command(json.dumps({
            'action': 'get_current_location',
            'params': {
                'session_id': session_id
            }
        }))
        
        response = json.loads(result)
        if response['success']:
            location = response['result']
            print(f"✓ Current location: {location.get('file')}:{location.get('line')}")
            print(f"  Function: {location.get('function')}")
        
        # Step 5: Get local variables
        print("\n[5] Getting local variables...")
        result = debugger.execute_command(json.dumps({
            'action': 'get_variables',
            'params': {
                'session_id': session_id,
                'scope': 'local'
            }
        }))
        
        response = json.loads(result)
        if response['success']:
            variables = response['result']['variables']
            print(f"✓ Found {len(variables)} variables:")
            for name, var in variables.items():
                print(f"  - {name} = {var.get('value')} ({var.get('type')})")
        
        # Step 6: Get call stack
        print("\n[6] Getting call stack...")
        result = debugger.execute_command(json.dumps({
            'action': 'get_backtrace',
            'params': {
                'session_id': session_id
            }
        }))
        
        response = json.loads(result)
        if response['success']:
            frames = response['result']['frames']
            print(f"✓ Call stack depth: {response['result']['depth']}")
            for i, frame in enumerate(frames[:5]):  # Show first 5 frames
                print(f"  #{frame['level']} {frame['func']} at {frame['file']}:{frame['line']}")
        
        # Step 7: Step through code
        print("\n[7] Stepping through code...")
        for i in range(3):
            result = debugger.execute_command(json.dumps({
                'action': 'next',
                'params': {
                    'session_id': session_id
                }
            }))
            
            response = json.loads(result)
            if response['success']:
                location = response['result']['location']
                print(f"  Step {i+1}: {location.get('file')}:{location.get('line')}")
        
        # Step 8: Evaluate an expression
        print("\n[8] Evaluating expression...")
        result = debugger.execute_command(json.dumps({
            'action': 'evaluate_expression',
            'params': {
                'session_id': session_id,
                'expression': 'argc'  # Example expression
            }
        }))
        
        response = json.loads(result)
        if response['success']:
            print(f"✓ Result: {response['result']}")
        else:
            print(f"✗ Evaluation failed: {response.get('error')}")
        
        # Step 9: Continue execution
        print("\n[9] Continuing execution...")
        result = debugger.execute_command(json.dumps({
            'action': 'continue',
            'params': {
                'session_id': session_id
            }
        }))
        
        response = json.loads(result)
        print(f"✓ State: {response['result']['state']}")
        
        # Step 10: Close session
        print("\n[10] Closing session...")
        result = debugger.execute_command(json.dumps({
            'action': 'close_session',
            'params': {
                'session_id': session_id
            }
        }))
        
        response = json.loads(result)
        if response['success']:
            print("✓ Session closed")
        
    except Exception as e:
        print(f"\n✗ Error: {e}")
        import traceback
        traceback.print_exc()
    
    finally:
        # Cleanup
        debugger.cleanup()
    
    print("\n" + "=" * 60)
    print("Example completed")
    print("=" * 60)


if __name__ == "__main__":
    main()