jvm_assembler/program/

entities.rs

use super::{
    instructions::JvmInstruction,
    pool::JvmConstantPool,
    types::{JvmAccessFlags, JvmAttribute, JvmBootstrapMethod, JvmField, JvmInnerClass, JvmVersion},
};

/// High-level representation of a JVM program
#[derive(Debug, Clone)]
pub struct JvmProgram {
    /// Program name (class name)
    pub name: String,
    /// Access flags
    pub access_flags: JvmAccessFlags,
    /// Super class name
    pub super_class: Option<String>,
    /// List of implemented interfaces
    pub interfaces: Vec<String>,
    /// List of fields
    pub fields: Vec<JvmField>,
    /// List of methods
    pub methods: Vec<JvmMethod>,
    /// List of attributes
    pub attributes: Vec<JvmAttribute>,
    /// Constant pool (high-level representation)
    pub constant_pool: JvmConstantPool,
    /// Version information
    pub version: JvmVersion,
    /// Source file information
    pub source_file: Option<String>,
    /// List of inner classes
    pub inner_classes: Vec<JvmInnerClass>,
    /// Enclosing method information
    pub enclosing_method: Option<(String, Option<String>, Option<String>)>, // (class_name, method_name, method_descriptor)
}

impl JvmProgram {
    /// Creates a new JVM program with given name
    pub fn new(name: String) -> Self {
        Self {
            name,
            access_flags: JvmAccessFlags::public(),
            super_class: None,
            interfaces: Vec::new(),
            fields: Vec::new(),
            methods: Vec::new(),
            attributes: Vec::new(),
            constant_pool: JvmConstantPool::new(),
            version: JvmVersion::java_8(),
            source_file: None,
            inner_classes: Vec::new(),
            enclosing_method: None,
        }
    }

    /// Sets JVM version
    pub fn set_version(&mut self, major: u16, minor: u16) {
        self.version = JvmVersion::new(major, minor);
    }

    /// Sets super class name
    pub fn set_super_class(&mut self, super_class: String) {
        self.super_class = Some(super_class);
    }

    /// Adds an interface to the program
    pub fn add_interface(&mut self, interface: String) {
        self.interfaces.push(interface);
    }

    /// Adds a method to the program
    pub fn add_method(&mut self, method: JvmMethod) {
        self.methods.push(method);
    }

    /// Adds a field to the program
    pub fn add_field(&mut self, field: JvmField) {
        self.fields.push(field);
    }

    /// Adds an attribute to the program
    pub fn add_attribute(&mut self, attribute: JvmAttribute) {
        self.attributes.push(attribute);
    }

    /// Sets source file name and adds SourceFile attribute
    pub fn set_source_file(&mut self, filename: String) {
        self.source_file = Some(filename.clone());
        self.add_attribute(JvmAttribute::SourceFile { filename });
    }

    /// Validates the program
    pub fn validate(&self) -> bool {
        // Basic validation logic
        if self.name.is_empty() {
            return false;
        }
        true
    }

    /// Adds a bootstrap method to the program
    pub fn add_bootstrap_method(&mut self, method_ref: u16, arguments: Vec<u16>) {
        // Check if BootstrapMethods attribute already exists
        if let Some(JvmAttribute::BootstrapMethods { methods }) = self.attributes.iter_mut().find(|attr| {
            matches!(attr, JvmAttribute::BootstrapMethods { .. })
        }) {
            methods.push(JvmBootstrapMethod { method_ref, arguments });
        } else {
            // Create new BootstrapMethods attribute
            let bootstrap_method = JvmBootstrapMethod { method_ref, arguments };
            self.add_attribute(JvmAttribute::BootstrapMethods { methods: vec![bootstrap_method] });
        }
    }

    /// Creates a synthetic method for lambda expression
    pub fn create_lambda_method(&mut self, name: String, descriptor: String, instructions: Vec<JvmInstruction>) -> JvmMethod {
        let mut method = JvmMethod::new(name, descriptor);
        method.access_flags.is_private = true;
        method.access_flags.is_static = true;
        method.access_flags.is_synthetic = true;
        method.instructions = instructions;
        method.max_stack = 10; // Default value, should be calculated properly
        method.max_locals = 10; // Default value, should be calculated properly
        method
    }

    /// Creates a method reference bootstrap method
    pub fn create_method_reference_bootstrap(&mut self, method_ref: u16, method_type: u16) {
        // Create bootstrap method for method reference
        let arguments = vec![method_type];
        self.add_bootstrap_method(method_ref, arguments);
    }

    /// Adds an inner class to the program
    pub fn add_inner_class(&mut self, inner_class: JvmInnerClass) {
        self.inner_classes.push(inner_class);
    }

    /// Adds InnerClasses attribute to the program
    pub fn add_inner_classes_attribute(&mut self) {
        if !self.inner_classes.is_empty() {
            self.add_attribute(JvmAttribute::InnerClasses { classes: self.inner_classes.clone() });
        }
    }

    /// Sets enclosing method information
    pub fn set_enclosing_method(&mut self, class_name: String, method_name: Option<String>, method_descriptor: Option<String>) {
        self.enclosing_method = Some((class_name, method_name, method_descriptor));
    }

    /// Adds EnclosingMethod attribute to the program
    pub fn add_enclosing_method_attribute(&mut self) {
        if let Some((class_name, method_name, method_descriptor)) = &self.enclosing_method {
            self.add_attribute(JvmAttribute::EnclosingMethod {
                class_name: class_name.clone(),
                method_name: method_name.clone(),
                method_descriptor: method_descriptor.clone(),
            });
        }
    }
}

/// JVM method information
#[derive(Debug, Clone)]
pub struct JvmMethod {
    /// Method name
    pub name: String,
    /// Method descriptor
    pub descriptor: String,
    /// Access flags
    pub access_flags: JvmAccessFlags,
    /// Method instructions
    pub instructions: Vec<JvmInstruction>,
    /// Maximum stack size
    pub max_stack: u16,
    /// Maximum local variables
    pub max_locals: u16,
    /// Exception handler table
    pub exception_handlers: Vec<JvmExceptionHandler>,
    /// Exceptions thrown by the method
    pub exceptions: Vec<String>,
    /// Method attributes
    pub attributes: Vec<JvmAttribute>,
}

impl JvmMethod {
    /// Creates a new JVM method
    pub fn new(name: String, descriptor: String) -> Self {
        Self {
            name,
            descriptor,
            access_flags: JvmAccessFlags::public(),
            instructions: Vec::new(),
            max_stack: 0,
            max_locals: 0,
            exception_handlers: Vec::new(),
            exceptions: Vec::new(),
            attributes: Vec::new(),
        }
    }

    /// Adds an instruction to the method
    pub fn add_instruction(&mut self, inst: JvmInstruction) {
        self.instructions.push(inst);
    }

    /// Adds an exception handler to the method
    pub fn add_exception_handler(&mut self, handler: JvmExceptionHandler) {
        self.exception_handlers.push(handler);
    }

    /// Adds an exception to the method
    pub fn add_exception(&mut self, exception: String) {
        self.exceptions.push(exception);
    }

    /// Adds an attribute to the method
    pub fn add_attribute(&mut self, attribute: JvmAttribute) {
        self.attributes.push(attribute);
    }
}

/// JVM exception handler
#[derive(Debug, Clone)]
pub struct JvmExceptionHandler {
    /// Start label
    pub start_label: String,
    /// End label
    pub end_label: String,
    /// Handler label
    pub handler_label: String,
    /// Catch type (class name)
    pub catch_type: Option<String>,
}