jsxbin-parser 1.0.0

Binary parser for Adobe JSX .jsxbin files with comprehensive AST representation
Documentation
use crate::binary_reader::BinaryReader;
use crate::error::{ParserError, ParserResult};
use crate::types::{Block, JsxBinFile, Token, FileMetadata, Opcode};
use log::{debug, trace};
use std::time::Instant;

/// Main JSXBIN file parser
pub struct JsxbinParser {
    reader: BinaryReader,
    string_table: Vec<String>,
    offset: usize,
}

impl JsxbinParser {
    /// Create a new parser from binary data
    pub fn new(data: Vec<u8>) -> Self {
        let len = data.len();
        JsxbinParser {
            reader: BinaryReader::new(data),
            string_table: Vec::new(),
            offset: 0,
        }
    }

    /// Parse the JSXBIN file
    pub fn parse(&mut self) -> ParserResult<JsxBinFile> {
        let start = Instant::now();
        debug!("Starting JSXBIN parsing");

        // Read and validate magic bytes
        let magic1 = self.reader.read_u8()?;
        let magic2 = self.reader.read_u8()?;

        if magic1 != 0x4A || magic2 != 0x58 {
            // 0x4A = 'J', 0x58 = 'X'
            return Err(ParserError::InvalidMagic(magic1, magic2));
        }
        debug!("✓ Valid magic bytes (JX)");

        // Read version
        let version = self.reader.read_u32_le()?;
        debug!("Version: {}", version);

        if version > 1 {
            return Err(ParserError::UnsupportedVersion(version));
        }

        // Read target engine (null-terminated string)
        let target_engine = self.reader.read_cstring()?;
        debug!("Target engine: {}", target_engine);

        // Read string table
        let string_count = self.reader.read_u32_le()? as usize;
        debug!("Reading {} strings", string_count);

        self.string_table.clear();
        for i in 0..string_count {
            let str_len = self.reader.read_u32_le()? as usize;
            let string = self.reader.read_string(str_len)?;
            trace!("String[{}]: {}", i, string);
            self.string_table.push(string);
        }
        debug!("✓ String table loaded");

        // Parse token stream
        let mut tokens = Vec::new();
        while !self.reader.is_eof() {
            match self.parse_token() {
                Ok(token) => {
                    if let Token::Unknown(_) = token {
                        // Skip unknown tokens
                        trace!("Skipping unknown token at offset {}", self.reader.position());
                    }
                    tokens.push(token);
                }
                Err(e) => {
                    log::warn!("Error parsing token: {}", e);
                    break;
                }
            }
        }
        debug!("✓ Parsed {} tokens", tokens.len());

        let parse_time_ms = start.elapsed().as_millis() as u64;

        let metadata = FileMetadata {
            file_size: self.reader.len(),
            parse_time_ms,
            token_count: tokens.len(),
            string_count,
        };

        Ok(JsxBinFile {
            version,
            target_engine,
            string_table: self.string_table.clone(),
            tokens,
            metadata,
        })
    }

    /// Parse a single token
    fn parse_token(&mut self) -> ParserResult<Token> {
        let opcode_byte = self.reader.read_u8()?;

        if let Some(opcode) = Opcode::from_byte(opcode_byte) {
            trace!("Parsing opcode: {:?} (0x{:02x})", opcode, opcode_byte);

            match opcode {
                Opcode::EndOfStatement => Ok(Token::Block(Block {
                    statements: Vec::new(),
                })),

                Opcode::Null => Ok(Token::Null),

                Opcode::Undefined => Ok(Token::Undefined),

                Opcode::Number => {
                    let value = self.reader.read_f64_le()?;
                    Ok(Token::NumberLiteral(value))
                }

                Opcode::String => {
                    let index = self.reader.read_u32_le()? as usize;
                    if index >= self.string_table.len() {
                        return Err(ParserError::InvalidStringIndex(index));
                    }
                    Ok(Token::StringLiteral(self.string_table[index].clone()))
                }

                Opcode::Boolean => {
                    let value = self.reader.read_u8()? != 0;
                    Ok(Token::BooleanLiteral(value))
                }

                Opcode::Identifier => {
                    let index = self.reader.read_u32_le()? as usize;
                    if index >= self.string_table.len() {
                        return Err(ParserError::InvalidStringIndex(index));
                    }
                    Ok(Token::Identifier(self.string_table[index].clone()))
                }

                Opcode::Function => {
                    let name_index = self.reader.read_u32_le()? as usize;
                    let name = if name_index < self.string_table.len() {
                        self.string_table[name_index].clone()
                    } else {
                        format!("function_{}", name_index)
                    };

                    let param_count = self.reader.read_u32_le()? as usize;
                    let mut params = Vec::new();
                    for _ in 0..param_count {
                        let param_index = self.reader.read_u32_le()? as usize;
                        if param_index < self.string_table.len() {
                            params.push(self.string_table[param_index].clone());
                        }
                    }

                    // TODO: Parse function body
                    let body = Box::new(Block {
                        statements: Vec::new(),
                    });

                    Ok(Token::Function { name, params, body })
                }

                Opcode::Return => {
                    // TODO: Parse return value
                    Ok(Token::ReturnStatement(None))
                }

                Opcode::If => {
                    // TODO: Parse if condition and branches
                    Ok(Token::IfStatement {
                        condition: Box::new(Token::BooleanLiteral(true).into()),
                        consequent: Box::new(Block {
                            statements: Vec::new(),
                        }),
                        alternate: None,
                    })
                }

                Opcode::While => {
                    // TODO: Parse while loop
                    Ok(Token::WhileLoop {
                        condition: Box::new(Token::BooleanLiteral(true).into()),
                        body: Box::new(Block {
                            statements: Vec::new(),
                        }),
                    })
                }

                Opcode::Break => Ok(Token::BreakStatement),

                Opcode::Continue => Ok(Token::ContinueStatement),

                Opcode::Plus => {
                    // Binary operation - requires operands
                    Ok(Token::Identifier("+".to_string()))
                }

                _ => {
                    let raw = vec![opcode_byte];
                    Ok(Token::Unknown(raw))
                }
            }
        } else {
            let raw = vec![opcode_byte];
            Ok(Token::Unknown(raw))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_invalid_magic() {
        let data = vec![0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00];
        let mut parser = JsxbinParser::new(data);
        assert!(parser.parse().is_err());
    }

    #[test]
    fn test_valid_header() {
        let mut data = vec![
            0x4A, 0x58, // Magic "JX"
            0x01, 0x00, 0x00, 0x00, // Version 1
        ];
        // Add null-terminated engine string
        data.extend_from_slice(b"ExtendScript\0");
        // Add empty string table
        data.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); // 0 strings

        let mut parser = JsxbinParser::new(data);
        let result = parser.parse();
        assert!(result.is_ok());
        if let Ok(file) = result {
            assert_eq!(file.version, 1);
        }
    }
}