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;
pub struct JsxbinParser {
reader: BinaryReader,
string_table: Vec<String>,
offset: usize,
}
impl JsxbinParser {
pub fn new(data: Vec<u8>) -> Self {
let len = data.len();
JsxbinParser {
reader: BinaryReader::new(data),
string_table: Vec::new(),
offset: 0,
}
}
pub fn parse(&mut self) -> ParserResult<JsxBinFile> {
let start = Instant::now();
debug!("Starting JSXBIN parsing");
let magic1 = self.reader.read_u8()?;
let magic2 = self.reader.read_u8()?;
if magic1 != 0x4A || magic2 != 0x58 {
return Err(ParserError::InvalidMagic(magic1, magic2));
}
debug!("✓ Valid magic bytes (JX)");
let version = self.reader.read_u32_le()?;
debug!("Version: {}", version);
if version > 1 {
return Err(ParserError::UnsupportedVersion(version));
}
let target_engine = self.reader.read_cstring()?;
debug!("Target engine: {}", target_engine);
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");
let mut tokens = Vec::new();
while !self.reader.is_eof() {
match self.parse_token() {
Ok(token) => {
if let Token::Unknown(_) = token {
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,
})
}
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());
}
}
let body = Box::new(Block {
statements: Vec::new(),
});
Ok(Token::Function { name, params, body })
}
Opcode::Return => {
Ok(Token::ReturnStatement(None))
}
Opcode::If => {
Ok(Token::IfStatement {
condition: Box::new(Token::BooleanLiteral(true).into()),
consequent: Box::new(Block {
statements: Vec::new(),
}),
alternate: None,
})
}
Opcode::While => {
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 => {
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, 0x01, 0x00, 0x00, 0x00, ];
data.extend_from_slice(b"ExtendScript\0");
data.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]);
let mut parser = JsxbinParser::new(data);
let result = parser.parse();
assert!(result.is_ok());
if let Ok(file) = result {
assert_eq!(file.version, 1);
}
}
}