compiler_gui.py

"""
Modern Web-based Compiler GUI Server

A beautiful, interactive web interface for the compiler with:
- Stunning gradient designs
- Smooth animations
- Modern typography (Helvetica, Inter)
- Real-time compilation visualization
- Interactive phase transitions
"""

from flask import Flask, render_template, request, jsonify
import sys
from io import StringIO

from lexer import Lexer, TokenType
from ast_parser import Parser
from semantic import SemanticAnalyzer
from intermediate import IntermediateCodeGenerator
from interpreter import Interpreter

app = Flask(__name__)


def capture_ast_output(ast):
    """Capture AST print output"""
    from ast_parser import print_ast
    old_stdout = sys.stdout
    sys.stdout = StringIO()
    print_ast(ast)
    output = sys.stdout.getvalue()
    sys.stdout = old_stdout
    return output


@app.route('/')
def index():
    """Serve the main page"""
    return render_template('index.html')


@app.route('/compile', methods=['POST'])
def compile_code():
    """Compile the source code and return results for all phases"""
    try:
        source_code = request.json.get('code', '')
        
        results = {
            'success': True,
            'phases': []
        }
        
        # Phase 1: Lexical Analysis
        try:
            lexer = Lexer(source_code)
            tokens = lexer.tokenize()
            
            token_list = []
            for i, token in enumerate(tokens):
                if token.type != TokenType.EOF:
                    token_list.append({
                        'index': i,
                        'type': token.type.name,
                        'value': token.value,
                        'position': token.position
                    })
            
            results['phases'].append({
                'name': 'Lexical Analysis',
                'status': 'success',
                'data': {
                    'tokens': token_list,
                    'count': len(token_list)
                }
            })
        except Exception as e:
            results['success'] = False
            results['phases'].append({
                'name': 'Lexical Analysis',
                'status': 'error',
                'error': str(e)
            })
            return jsonify(results)
        
        # Phase 2: Parsing
        try:
            parser = Parser(tokens)
            ast = parser.parse()
            ast_output = capture_ast_output(ast)
            
            results['phases'].append({
                'name': 'Syntax Analysis',
                'status': 'success',
                'data': {
                    'ast': ast_output
                }
            })
        except Exception as e:
            results['success'] = False
            results['phases'].append({
                'name': 'Syntax Analysis',
                'status': 'error',
                'error': str(e)
            })
            return jsonify(results)
        
        # Phase 3: Semantic Analysis
        try:
            analyzer = SemanticAnalyzer()
            old_stdout = sys.stdout
            sys.stdout = StringIO()
            is_valid = analyzer.analyze(ast)
            sys.stdout = old_stdout
            
            if is_valid:
                results['phases'].append({
                    'name': 'Semantic Analysis',
                    'status': 'success',
                    'data': {
                        'symbols': list(analyzer.symbol_table.symbols.keys())
                    }
                })
            else:
                results['success'] = False
                results['phases'].append({
                    'name': 'Semantic Analysis',
                    'status': 'error',
                    'error': '; '.join(analyzer.errors)
                })
                return jsonify(results)
        except Exception as e:
            results['success'] = False
            results['phases'].append({
                'name': 'Semantic Analysis',
                'status': 'error',
                'error': str(e)
            })
            return jsonify(results)
        
        # Phase 4: Code Generation
        try:
            generator = IntermediateCodeGenerator()
            old_stdout = sys.stdout
            sys.stdout = StringIO()
            tac = generator.generate(ast)
            sys.stdout = old_stdout
            
            tac_list = []
            for i, instr in enumerate(tac):
                tac_list.append({
                    'index': i,
                    'instruction': str(instr)
                })
            
            results['phases'].append({
                'name': 'Code Generation',
                'status': 'success',
                'data': {
                    'tac': tac_list,
                    'count': len(tac_list)
                }
            })
        except Exception as e:
            results['success'] = False
            results['phases'].append({
                'name': 'Code Generation',
                'status': 'error',
                'error': str(e)
            })
            return jsonify(results)
        
        # Phase 5: Execution
        try:
            interpreter = Interpreter(tac)
            
            # Capture output
            old_stdout = sys.stdout
            sys.stdout = StringIO()
            
            execution_log = []
            for i, instruction in enumerate(tac):
                interpreter.pc = i
                interpreter.execute_instruction(instruction)
            
            output = sys.stdout.getvalue()
            sys.stdout = old_stdout
            
            # Extract OUTPUT lines
            program_output = []
            for line in output.split('\n'):
                if line.startswith('OUTPUT:'):
                    program_output.append(line.replace('OUTPUT:', '').strip())
            
            results['phases'].append({
                'name': 'Execution',
                'status': 'success',
                'data': {
                    'output': program_output,
                    'memory': {k: v for k, v in interpreter.memory.items() if not k.startswith('t')}
                }
            })
        except Exception as e:
            results['success'] = False
            results['phases'].append({
                'name': 'Execution',
                'status': 'error',
                'error': str(e)
            })
            return jsonify(results)
        
        return jsonify(results)
        
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        })


if __name__ == '__main__':
    print("🚀 Starting Compiler Web Interface...")
    print("📱 Open your browser and go to: http://localhost:5000")
    print("✨ Enjoy the beautiful, interactive compiler GUI!")
    app.run(debug=True, port=5000)