def semantic_analysis(ast, symbol_table):
    """Realiza análise semântica na AST"""
    if ast is None:
        return None
        
    # Verifica o tipo do nó atual
    if ast.node_type == 'BinaryOp':
        # Analisa recursivamente os operandos
        left_type = semantic_analysis(ast.left, symbol_table)
        right_type = semantic_analysis(ast.right, symbol_table)
        
        # Verifica compatibilidade de tipos
        if ast.op in ['+', '-', '*', '/']:
            if left_type == 'int' and right_type == 'int':
                return 'int'
            elif left_type in ['int', 'float'] and right_type in ['int', 'float']:
                return 'float'
            else:
                raise SemanticError(f"Operador '{ast.op}' incompatível com tipos {left_type} e {right_type}", ast.line)
    
    elif ast.node_type == 'VarDecl':
        # Registra variável na tabela de símbolos
        if not symbol_table.insert(ast.name, ast.type, ast.line):
            raise SemanticError(f"Variável '{ast.name}' já declarada", ast.line)
        return None
    
    # Outros tipos de nós...

class TACGenerator:
    def __init__(self):
        self.instructions = []
        self.temp_counter = 0
        self.label_counter = 0
        
    def new_temp(self):
        """Cria um novo nome de variável temporária"""
        temp = f"t{self.temp_counter}"
        self.temp_counter += 1
        return temp
        
    def new_label(self):
        """Cria um novo rótulo para saltos"""
        label = f"L{self.label_counter}"
        self.label_counter += 1
        return label
        
    def generate(self, ast):
        """Gera código TAC a partir da AST"""
        return self._generate_node(ast)
        
    def _generate_node(self, node):
        if node is None:
            return None
            
        if node.node_type == 'BinaryOp':
            # Gera código para os operandos
            left_result = self._generate_node(node.left)
            right_result = self._generate_node(node.right)
            
            # Cria temporário para o resultado
            result = self.new_temp()
            
            # Adiciona instrução TAC
            self.instructions.append(f"{result} = {left_result} {node.op} {right_result}")
            return result
            
        elif node.node_type == 'Num':
            return str(node.value)
            
        elif node.node_type == 'Var':
            return node.name
            
        # Implementação para outros tipos de nós...

a = 5
b = 10
c = 15     // a + b calculado em tempo de compilação
d = 30     // c * 2 calculado em tempo de compilação
temp1 = 1  // 5 > 0 avaliado como verdadeiro (1)
// if_false removido pois condição é sempre verdadeira
e = 45     // c + d calculado em tempo de compilação
print 45   // valor de e propagado
// L1 removido pois é código morto

# compiler.py
import lexer
import parser
import semantic
import codegen
import optimizer
import os

def compile_file(input_file, output_file):
    """Compila um arquivo fonte para o arquivo de saída"""
    try:
        # Lê o arquivo fonte
        with open(input_file, 'r') as f:
            source_code = f.read()
        
        # Pipeline de compilação
        print(f"Compilando {input_file}...")
        
        # 1. Análise léxica
        print("Realizando análise léxica...")
        tokens = lexer.tokenize(source_code)
        
        # 2. Análise sintática
        print("Realizando análise sintática...")
        ast = parser.parse(tokens)
        
        # 3. Análise semântica
        print("Realizando análise semântica...")
        symbol_table = semantic.analyze(ast)
        
        # 4. Geração de código TAC
        print("Gerando código intermediário...")
        tac_code = codegen.generate_tac(ast, symbol_table)
        
        # 5. Otimização
        print("Otimizando código...")
        optimized_tac = optimizer.optimize(tac_code)
        
        # 6. Emissão de código final
        print("Gerando código final...")
        final_code = codegen.emit_python(optimized_tac)
        
        # Escreve o código no arquivo de saída
        with open(output_file, 'w') as f:
            f.write(final_code)
            
        print(f"Compilação concluída. Código gerado em {output_file}")
        return True
        
    except Exception as e:
        print(f"Erro durante a compilação: {e}")
        return False

if __name__ == "__main__":
    import sys
    if len(sys.argv) != 3:
        print("Uso: python compiler.py arquivo_entrada.src arquivo_saida.py")
    else:
        compile_file(sys.argv[1], sys.argv[2])

class CompilationError(Exception):
    def __init__(self, phase, message, line=None, column=None):
        self.phase = phase  # 'lexical', 'syntax', 'semantic', 'codegen'
        self.message = message
        self.line = line
        self.column = column
        super().__init__(self.format_message())
        
    def format_message(self):
        location = ""
        if self.line is not None:
            location += f" na linha {self.line}"
            if self.column is not None:
                location += f", coluna {self.column}"
                
        return f"Erro {self.phase}{location}: {self.message}"

# No pipeline de compilação:
try:
    # Código de compilação
    pass
except CompilationError as e:
    print(e)
    # Registra o erro em um log
    with open('compile_errors.log', 'a') as log:
        log.write(f"{datetime.now()}: {str(e)}\n")

programa {
    // Função para calcular fatorial
    int fatorial(int n) {
        if (n <= 1) {
            return 1;
        } else {
            return n * fatorial(n - 1);
        }
    }
    
    // Função para verificar se um número é primo
    bool ehPrimo(int num) {
        if (num <= 1) {
            return false;
        }
        
        int i = 2;
        while (i * i <= num) {
            if (num % i == 0) {
                return false;
            }
            i = i + 1;
        }
        
        return true;
    }
    
    // Programa principal
    int numero = 5;
    
    print("Fatorial de " + numero + " é " + fatorial(numero));
    
    if (ehPrimo(numero)) {
        print(numero + " é primo");
    } else {
        print(numero + " não é primo");
    }
}