virtual-machine 0.0.3 → 0.0.10

package/src/net_ws.rs

@@ -1,396 +0,0 @@
-//! WebSocket network backend for cross-platform networking.
-//!
-//! This backend tunnels Ethernet frames over WebSocket, enabling
-//! networking on platforms without TAP support (macOS, WASM/browser).
-
-use crate::net::NetworkBackend;
-use std::sync::mpsc::{channel, Receiver, Sender, TryRecvError};
-use std::sync::{Arc, Mutex};
-
-#[cfg(not(target_arch = "wasm32"))]
-mod native {
-    use super::*;
-    use std::thread;
-    use tungstenite::{connect, Message, WebSocket};
-    use tungstenite::stream::MaybeTlsStream;
-    use std::net::TcpStream;
-
-    /// WebSocket backend for native platforms (macOS, Linux, Windows).
-    pub struct WsBackend {
-        url: String,
-        mac: [u8; 6],
-        tx_to_ws: Option<Sender<Vec<u8>>>,
-        rx_from_ws: Option<Receiver<Vec<u8>>>,
-        connected: Arc<Mutex<bool>>,
-        error_message: Arc<Mutex<Option<String>>>,
-    }
-
-    impl WsBackend {
-        pub fn new(url: &str) -> Self {
-            // Generate a random-ish MAC based on URL hash
-            let mut mac = [0x52, 0x54, 0x00, 0x00, 0x00, 0x00];
-            let hash: u32 = url.bytes().fold(0u32, |acc, b| acc.wrapping_mul(31).wrapping_add(b as u32));
-            mac[3] = ((hash >> 16) & 0xff) as u8;
-            mac[4] = ((hash >> 8) & 0xff) as u8;
-            mac[5] = (hash & 0xff) as u8;
-            
-            Self {
-                url: url.to_string(),
-                mac,
-                tx_to_ws: None,
-                rx_from_ws: None,
-                connected: Arc::new(Mutex::new(false)),
-                error_message: Arc::new(Mutex::new(None)),
-            }
-        }
-        
-        /// Check if the backend is currently connected.
-        pub fn is_connected(&self) -> bool {
-            *self.connected.lock().unwrap()
-        }
-        
-        /// Get any error message from the connection.
-        pub fn error_message(&self) -> Option<String> {
-            self.error_message.lock().unwrap().clone()
-        }
-
-        /// Reader thread - reads from WebSocket and sends to channel
-        fn reader_thread(
-            mut socket: WebSocket<MaybeTlsStream<TcpStream>>,
-            tx_received: Sender<Vec<u8>>,
-            rx_to_send: Receiver<Vec<u8>>,
-            connected: Arc<Mutex<bool>>,
-        ) {
-            // Set socket to blocking mode for reliable reads
-            if let MaybeTlsStream::Plain(ref stream) = *socket.get_ref() {
-                let _ = stream.set_nonblocking(false);
-                // Set a read timeout so we can also check for outgoing messages
-                let _ = stream.set_read_timeout(Some(std::time::Duration::from_millis(10)));
-            }
-            
-            loop {
-                // First, check if we have outgoing messages to send
-                loop {
-                    match rx_to_send.try_recv() {
-                        Ok(data) => {
-                            log::trace!("[WsBackend] Sending {} bytes", data.len());
-                            if let Err(e) = socket.send(Message::Binary(data.into())) {
-                                log::warn!("[WsBackend] Send error: {}", e);
-                                *connected.lock().unwrap() = false;
-                                return;
-                            }
-                        }
-                        Err(TryRecvError::Empty) => break,
-                        Err(TryRecvError::Disconnected) => {
-                            log::info!("[WsBackend] Send channel closed, exiting");
-                            *connected.lock().unwrap() = false;
-                            return;
-                        }
-                    }
-                }
-                
-                // Flush any pending writes
-                if let Err(e) = socket.flush() {
-                    if !matches!(e, tungstenite::Error::Io(ref io) if io.kind() == std::io::ErrorKind::WouldBlock) {
-                        log::warn!("[WsBackend] Flush error: {}", e);
-                    }
-                }
-                
-                // Try to read from WebSocket
-                match socket.read() {
-                    Ok(Message::Binary(data)) => {
-                        log::debug!("[WsBackend] Received {} bytes from relay", data.len());
-                        if tx_received.send(data.into()).is_err() {
-                            log::info!("[WsBackend] Receiver dropped, exiting");
-                            *connected.lock().unwrap() = false;
-                            return;
-                        }
-                    }
-                    Ok(Message::Close(_)) => {
-                        log::info!("[WsBackend] WebSocket closed by server");
-                        *connected.lock().unwrap() = false;
-                        return;
-                    }
-                    Ok(Message::Ping(data)) => {
-                        // Respond to ping with pong
-                        let _ = socket.send(Message::Pong(data));
-                    }
-                    Ok(_) => {} // Ignore text, pong
-                    Err(tungstenite::Error::Io(ref e)) if e.kind() == std::io::ErrorKind::WouldBlock => {
-                        // Timeout - no data available, continue loop
-                    }
-                    Err(tungstenite::Error::Io(ref e)) if e.kind() == std::io::ErrorKind::TimedOut => {
-                        // Timeout - no data available, continue loop
-                    }
-                    Err(e) => {
-                        log::warn!("[WsBackend] Read error: {}", e);
-                        *connected.lock().unwrap() = false;
-                        return;
-                    }
-                }
-            }
-        }
-    }
-
-    impl NetworkBackend for WsBackend {
-        fn init(&mut self) -> Result<(), String> {
-            log::info!("[WsBackend] Connecting to {}", self.url);
-            
-            let (socket, _response) = connect(&self.url)
-                .map_err(|e| {
-                    let msg = format!("Failed to connect: {}", e);
-                    log::error!("[WsBackend] {}", msg);
-                    *self.error_message.lock().unwrap() = Some(msg.clone());
-                    msg
-                })?;
-            
-            log::info!("[WsBackend] Connected successfully!");
-            *self.connected.lock().unwrap() = true;
-            *self.error_message.lock().unwrap() = None;
-            
-            let (tx_to_ws, rx_to_send) = channel();
-            let (tx_received, rx_from_ws) = channel();
-            
-            self.tx_to_ws = Some(tx_to_ws);
-            self.rx_from_ws = Some(rx_from_ws);
-            
-            let connected = self.connected.clone();
-            
-            thread::spawn(move || {
-                Self::reader_thread(socket, tx_received, rx_to_send, connected);
-            });
-            
-            log::info!("[WsBackend] Initialized successfully");
-            Ok(())
-        }
-
-        fn recv(&mut self) -> Result<Option<Vec<u8>>, String> {
-            if let Some(ref rx) = self.rx_from_ws {
-                match rx.try_recv() {
-                    Ok(data) => {
-                        log::trace!("[WsBackend] recv() returning {} bytes", data.len());
-                        Ok(Some(data))
-                    }
-                    Err(TryRecvError::Empty) => Ok(None),
-                    Err(TryRecvError::Disconnected) => {
-                        Err("WebSocket disconnected".to_string())
-                    }
-                }
-            } else {
-                Ok(None)
-            }
-        }
-
-        fn send(&self, buf: &[u8]) -> Result<(), String> {
-            if !*self.connected.lock().unwrap() {
-                return Err("Not connected".to_string());
-            }
-            
-            if let Some(ref tx) = self.tx_to_ws {
-                tx.send(buf.to_vec()).map_err(|e| format!("Send failed: {}", e))
-            } else {
-                Err("WebSocket not initialized".to_string())
-            }
-        }
-
-        fn mac_address(&self) -> [u8; 6] {
-            self.mac
-        }
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-mod wasm {
-    use super::*;
-    use wasm_bindgen::prelude::*;
-    use wasm_bindgen::JsCast;
-    use web_sys::{WebSocket, MessageEvent, ErrorEvent, CloseEvent, BinaryType};
-    use js_sys::{ArrayBuffer, Uint8Array};
-    use std::cell::RefCell;
-    use std::rc::Rc;
-    use std::collections::VecDeque;
-
-    /// Maximum number of packets to buffer before dropping
-    const MAX_RX_QUEUE_SIZE: usize = 256;
-    
-    /// Connection state for tracking
-    #[derive(Clone, Copy, PartialEq, Eq, Debug)]
-    pub enum ConnectionState {
-        Disconnected,
-        Connecting,
-        Connected,
-        Error,
-    }
-
-    /// WebSocket backend for WASM/browser.
-    pub struct WsBackend {
-        url: String,
-        mac: [u8; 6],
-        ws: Option<WebSocket>,
-        rx_queue: Rc<RefCell<VecDeque<Vec<u8>>>>,
-        state: Rc<RefCell<ConnectionState>>,
-        error_message: Rc<RefCell<Option<String>>>,
-        packets_dropped: Rc<RefCell<u64>>,
-    }
-
-    // WASM types are !Send by default, but we need Send for NetworkBackend.
-    // This is safe because WASM is single-threaded.
-    unsafe impl Send for WsBackend {}
-
-    impl WsBackend {
-        pub fn new(url: &str) -> Self {
-            let mut mac = [0x52, 0x54, 0x00, 0x00, 0x00, 0x00];
-            let hash: u32 = url.bytes().fold(0u32, |acc, b| acc.wrapping_mul(31).wrapping_add(b as u32));
-            mac[3] = ((hash >> 16) & 0xff) as u8;
-            mac[4] = ((hash >> 8) & 0xff) as u8;
-            mac[5] = (hash & 0xff) as u8;
-            
-            Self {
-                url: url.to_string(),
-                mac,
-                ws: None,
-                rx_queue: Rc::new(RefCell::new(VecDeque::with_capacity(MAX_RX_QUEUE_SIZE))),
-                state: Rc::new(RefCell::new(ConnectionState::Disconnected)),
-                error_message: Rc::new(RefCell::new(None)),
-                packets_dropped: Rc::new(RefCell::new(0)),
-            }
-        }
-        
-        /// Check if the backend is currently connected.
-        pub fn is_connected(&self) -> bool {
-            *self.state.borrow() == ConnectionState::Connected
-        }
-        
-        /// Get the current connection state.
-        pub fn connection_state(&self) -> ConnectionState {
-            *self.state.borrow()
-        }
-        
-        /// Get any error message.
-        pub fn error_message(&self) -> Option<String> {
-            self.error_message.borrow().clone()
-        }
-        
-        /// Get the number of packets dropped due to buffer overflow.
-        pub fn packets_dropped(&self) -> u64 {
-            *self.packets_dropped.borrow()
-        }
-    }
-
-    impl NetworkBackend for WsBackend {
-        fn init(&mut self) -> Result<(), String> {
-            *self.state.borrow_mut() = ConnectionState::Connecting;
-            *self.error_message.borrow_mut() = None;
-            
-            let ws = WebSocket::new(&self.url)
-                .map_err(|e| {
-                    *self.state.borrow_mut() = ConnectionState::Error;
-                    let msg = format!("Failed to create WebSocket: {:?}", e);
-                    *self.error_message.borrow_mut() = Some(msg.clone());
-                    msg
-                })?;
-            
-            ws.set_binary_type(BinaryType::Arraybuffer);
-            
-            // Set up message handler with buffer overflow protection
-            let rx_queue = self.rx_queue.clone();
-            let packets_dropped = self.packets_dropped.clone();
-            let onmessage_callback = Closure::<dyn FnMut(_)>::new(move |e: MessageEvent| {
-                if let Ok(abuf) = e.data().dyn_into::<ArrayBuffer>() {
-                    let array = Uint8Array::new(&abuf);
-                    let mut data = vec![0u8; array.length() as usize];
-                    array.copy_to(&mut data);
-                    
-                    let mut queue = rx_queue.borrow_mut();
-                    // Handle buffer overflow - drop oldest packets if queue is full
-                    while queue.len() >= MAX_RX_QUEUE_SIZE {
-                        queue.pop_front();
-                        *packets_dropped.borrow_mut() += 1;
-                    }
-                    queue.push_back(data);
-                }
-            });
-            ws.set_onmessage(Some(onmessage_callback.as_ref().unchecked_ref()));
-            onmessage_callback.forget();
-            
-            // Set up open handler
-            let state_open = self.state.clone();
-            let error_clear = self.error_message.clone();
-            let onopen_callback = Closure::<dyn FnMut()>::new(move || {
-                *state_open.borrow_mut() = ConnectionState::Connected;
-                *error_clear.borrow_mut() = None;
-                log::info!("[WsBackend] WebSocket connected!");
-            });
-            ws.set_onopen(Some(onopen_callback.as_ref().unchecked_ref()));
-            onopen_callback.forget();
-            
-            // Set up error handler
-            let state_error = self.state.clone();
-            let error_message = self.error_message.clone();
-            let onerror_callback = Closure::<dyn FnMut(_)>::new(move |e: ErrorEvent| {
-                *state_error.borrow_mut() = ConnectionState::Error;
-                let msg = format!("WebSocket error: {}", e.message());
-                *error_message.borrow_mut() = Some(msg.clone());
-                log::error!("[WsBackend] {}", msg);
-            });
-            ws.set_onerror(Some(onerror_callback.as_ref().unchecked_ref()));
-            onerror_callback.forget();
-            
-            // Set up close handler
-            let state_close = self.state.clone();
-            let onclose_callback = Closure::<dyn FnMut(_)>::new(move |e: CloseEvent| {
-                *state_close.borrow_mut() = ConnectionState::Disconnected;
-                log::info!("[WsBackend] WebSocket closed (code: {}, reason: {})", 
-                    e.code(), e.reason());
-            });
-            ws.set_onclose(Some(onclose_callback.as_ref().unchecked_ref()));
-            onclose_callback.forget();
-            
-            self.ws = Some(ws);
-            
-            log::info!("[WsBackend] Initialized, connecting to {}", self.url);
-            Ok(())
-        }
-
-        fn recv(&mut self) -> Result<Option<Vec<u8>>, String> {
-            // Check connection state
-            let state = *self.state.borrow();
-            if state == ConnectionState::Error {
-                if let Some(msg) = self.error_message.borrow().clone() {
-                    return Err(msg);
-                }
-                return Err("WebSocket in error state".to_string());
-            }
-            
-            Ok(self.rx_queue.borrow_mut().pop_front())
-        }
-
-        fn send(&self, buf: &[u8]) -> Result<(), String> {
-            let state = *self.state.borrow();
-            
-            if state != ConnectionState::Connected {
-                // Silently drop if not connected (don't spam errors)
-                return Ok(());
-            }
-            
-            if let Some(ref ws) = self.ws {
-                let array = Uint8Array::from(buf);
-                ws.send_with_array_buffer(&array.buffer())
-                    .map_err(|e| format!("Send failed: {:?}", e))
-            } else {
-                Err("WebSocket not initialized".to_string())
-            }
-        }
-
-        fn mac_address(&self) -> [u8; 6] {
-            self.mac
-        }
-    }
-}
-
-// Re-export the appropriate backend based on target
-#[cfg(not(target_arch = "wasm32"))]
-pub use native::WsBackend;
-
-#[cfg(target_arch = "wasm32")]
-pub use wasm::WsBackend;

package/src/plic.rs

@@ -1,261 +0,0 @@
-use crate::dram::MemoryError;
-
-pub const PLIC_BASE: u64 = 0x0C00_0000;
-pub const PLIC_SIZE: u64 = 0x400_0000;
-
-pub const UART_IRQ: u32 = 10;
-pub const VIRTIO0_IRQ: u32 = 1;
-
-const NUM_SOURCES: usize = 32;
-const NUM_CONTEXTS: usize = 2; // 0 = M-mode hart0, 1 = S-mode hart0
-
-pub struct Plic {
-    pub priority: [u32; NUM_SOURCES],
-    pub pending: u32, // Level-triggered mirror of device IRQ lines (bit per source)
-    pub enable: [u32; NUM_CONTEXTS],
-    pub threshold: [u32; NUM_CONTEXTS],
-    pub active: [u32; NUM_CONTEXTS], // Per-context in-flight IRQs (claimed but not completed)
-    pub debug: bool,
-    // Multi-context arrays enable SMP readiness while preserving single-hart behavior.
-}
-
-impl Plic {
-    pub fn new() -> Self {
-        Self {
-            priority: [0; NUM_SOURCES],
-            pending: 0,
-            enable: [0; NUM_CONTEXTS],
-            threshold: [0; NUM_CONTEXTS],
-            active: [0; NUM_CONTEXTS],
-            debug: false,
-        }
-    }
-
-    pub fn update_pending(&mut self, source: u32) {
-        // Backward compatibility helper: set as pending (edge → level).
-        // Bus.refresh_irqs() may later clear this if device line is low.
-        if source < 32 {
-            if self.debug {
-                 eprintln!("[PLIC] Update Pending source={}", source);
-            }
-            self.pending |= 1 << source;
-        }
-    }
-
-    // New: level-triggered source line setter
-    pub fn set_source_level(&mut self, source: u32, level: bool) {
-        if source >= 32 {
-            return;
-        }
-        let was_pending = (self.pending & (1 << source)) != 0;
-        if level {
-            if self.debug && !was_pending {
-                 eprintln!("[PLIC] IRQ Line High: source={} enable[0]=0x{:x} enable[1]=0x{:x} prio={}", 
-                          source, self.enable[0], self.enable[1], self.priority[source as usize]);
-            }
-            self.pending |= 1 << source;
-        } else {
-            self.pending &= !(1 << source);
-        }
-    }
-
-    pub fn load(&mut self, offset: u64, size: u64) -> Result<u64, MemoryError> {
-        if size != 4 {
-            return Ok(0); 
-        }
-
-        // Priority registers: 0x000000 .. 0x0000FC (4 bytes each)
-        if offset < 0x001000 {
-            let idx = (offset >> 2) as usize;
-            if idx < NUM_SOURCES {
-                return Ok(self.priority[idx] as u64);
-            }
-        }
-        // Pending bits: 0x001000
-        if offset == 0x001000 {
-            return Ok(self.pending as u64);
-        }
-        // Enable per context: 0x002000 + 0x80 * context
-        if offset >= 0x002000 && offset < 0x002000 + 0x80 * (NUM_CONTEXTS as u64) {
-            let ctx = ((offset - 0x002000) / 0x80) as usize;
-            let inner = (offset - 0x002000) % 0x80;
-            if ctx < NUM_CONTEXTS && inner == 0 {
-                return Ok(self.enable[ctx] as u64);
-            }
-        }
-        // Context registers: threshold @ 0x200000 + 0x1000 * ctx, claim @ +4
-        if offset >= 0x200000 {
-            let ctx = ((offset - 0x200000) / 0x1000) as usize;
-            if ctx < NUM_CONTEXTS {
-                let base = 0x200000 + (0x1000 * ctx as u64);
-                if offset == base {
-                    return Ok(self.threshold[ctx] as u64);
-                }
-                if offset == base + 4 {
-                    let claim = self.claim_interrupt_for(ctx);
-                    if crate::plic::Plic::debug_trace() {
-                        eprintln!("[PLIC] SCLAIM ctx={} -> {}", ctx, claim);
-                    }
-                    return Ok(claim as u64);
-                }
-            }
-        }
-
-        Ok(0)
-    }
-
-    fn debug_trace() -> bool {
-        // Helper to check if trace logging is enabled without importing log everywhere if not needed
-        // or just use std::env
-        std::env::var("RUST_LOG").map(|s| s.contains("trace")).unwrap_or(false)
-    }
-
-    pub fn store(&mut self, offset: u64, size: u64, value: u64) -> Result<(), MemoryError> {
-        if size != 4 {
-            return Ok(());
-        }
-        let val = value as u32;
-
-        // Priority
-        if offset < 0x001000 {
-            let idx = (offset >> 2) as usize;
-            if idx < NUM_SOURCES {
-                self.priority[idx] = val;
-            }
-            return Ok(());
-        }
-        // Pending is read-only to software
-        if offset == 0x001000 {
-            return Ok(());
-        }
-        // Enable per context
-        if offset >= 0x002000 && offset < 0x002000 + 0x80 * (NUM_CONTEXTS as u64) {
-            let ctx = ((offset - 0x002000) / 0x80) as usize;
-            let inner = (offset - 0x002000) % 0x80;
-            if ctx < NUM_CONTEXTS && inner == 0 {
-                self.enable[ctx] = val;
-            }
-            return Ok(());
-        }
-        // Threshold / Claim-Complete per context
-        if offset >= 0x200000 {
-            let ctx = ((offset - 0x200000) / 0x1000) as usize;
-            if ctx < NUM_CONTEXTS {
-                let base = 0x200000 + (0x1000 * ctx as u64);
-                if offset == base {
-                    self.threshold[ctx] = val;
-                    return Ok(());
-                }
-                if offset == base + 4 {
-                    // Completion: value is the source ID to complete
-                    let id = (val & 0xffff) as u32;
-                    if id > 0 && (id as usize) < NUM_SOURCES {
-                        // eprintln!("[PLIC] Completed IRQ {} for context {}", id, ctx);
-                        self.active[ctx] &= !(1 << id);
-                    }
-                    return Ok(());
-                }
-            }
-            return Ok(());
-        }
-
-        Ok(())
-    }
-
-    fn eligible_for_context(&self, source: usize, ctx: usize) -> bool {
-        let pending = ((self.pending >> source) & 1) == 1;
-        let enabled = ((self.enable[ctx] >> source) & 1) == 1;
-        let over_threshold = self.priority[source] > self.threshold[ctx];
-        let not_active = ((self.active[ctx] >> source) & 1) == 0;
-        pending && enabled && over_threshold && not_active
-    }
-
-    pub fn claim_interrupt_for(&mut self, ctx: usize) -> u32 {
-        let mut max_prio = 0;
-        let mut max_id = 0;
-
-        for i in 1..NUM_SOURCES {
-            if self.eligible_for_context(i, ctx) {
-                let prio = self.priority[i];
-                if prio > max_prio {
-                    max_prio = prio;
-                    max_id = i as u32;
-                }
-            }
-        }
-
-        if max_id != 0 {
-            // eprintln!("[PLIC] Claimed IRQ {} for context {} (prio {})", max_id, ctx, max_prio);
-            // Mark in-flight for this context until completed.
-            self.active[ctx] |= 1 << max_id;
-        }
-        max_id
-    }
-    
-    pub fn is_interrupt_pending(&self) -> bool {
-        // For current single-hart flow, report S-mode context (1) if available, else context 0.
-        let ctx = if NUM_CONTEXTS > 1 { 1 } else { 0 };
-        self.is_interrupt_pending_for(ctx)
-    }
-
-    pub fn is_interrupt_pending_for(&self, ctx: usize) -> bool {
-        if ctx >= NUM_CONTEXTS {
-            return false;
-        }
-        for i in 1..NUM_SOURCES {
-            if self.eligible_for_context(i, ctx) {
-                if self.debug {
-                    eprintln!("[PLIC] Interrupt pending for ctx={} source={}", ctx, i);
-                }
-                return true;
-            }
-        }
-        // Debug: show why no interrupt
-        if self.debug && self.pending != 0 {
-            for i in 1..NUM_SOURCES {
-                let pending = ((self.pending >> i) & 1) == 1;
-                let enabled = ((self.enable[ctx] >> i) & 1) == 1;
-                let over_threshold = self.priority[i] > self.threshold[ctx];
-                let not_active = ((self.active[ctx] >> i) & 1) == 0;
-                if pending {
-                    eprintln!("[PLIC] Source {} pending but not eligible for ctx={}: enabled={} over_threshold={} (prio={} > thresh={}) not_active={}", 
-                             i, ctx, enabled, over_threshold, self.priority[i], self.threshold[ctx], not_active);
-                }
-            }
-        }
-        false
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_plic_claim_complete_context1() {
-        let mut plic = Plic::new();
-        // Priorities
-        plic.priority[1] = 5;
-        plic.priority[10] = 3;
-        // Enable sources 1 and 10 for context 1 (S-mode)
-        let enable_val = (1u32 << 1) | (1u32 << 10);
-        let _ = plic.store(0x002000 + 0x80 * 1, 4, enable_val as u64);
-        // Threshold 0 for context 1
-        let _ = plic.store(0x200000 + 0x1000 * 1, 4, 0);
-        // Assert device lines
-        plic.set_source_level(1, true);
-        plic.set_source_level(10, true);
-
-        // Claim highest priority first (source 1)
-        let id1 = plic.claim_interrupt_for(1);
-        assert_eq!(id1, 1);
-        // Next claim should return source 10 (since 1 is active)
-        let id2 = plic.claim_interrupt_for(1);
-        assert_eq!(id2, 10);
-        // Complete source 1
-        let _ = plic.store(0x200004 + 0x1000 * 1, 4, 1);
-        // Claim again should allow source 1
-        let id3 = plic.claim_interrupt_for(1);
-        assert_eq!(id3, 1);
-    }
-}