1use crate::binary_reader::BinaryReader;
2use crate::error::{ParserError, ParserResult};
3use crate::types::{Block, JsxBinFile, Token, FileMetadata, Opcode};
4use log::{debug, trace};
5use std::time::Instant;
6
7pub struct JsxbinParser {
9 reader: BinaryReader,
10 string_table: Vec<String>,
11 offset: usize,
12}
13
14impl JsxbinParser {
15 pub fn new(data: Vec<u8>) -> Self {
17 let len = data.len();
18 JsxbinParser {
19 reader: BinaryReader::new(data),
20 string_table: Vec::new(),
21 offset: 0,
22 }
23 }
24
25 pub fn parse(&mut self) -> ParserResult<JsxBinFile> {
27 let start = Instant::now();
28 debug!("Starting JSXBIN parsing");
29
30 let magic1 = self.reader.read_u8()?;
32 let magic2 = self.reader.read_u8()?;
33
34 if magic1 != 0x4A || magic2 != 0x58 {
35 return Err(ParserError::InvalidMagic(magic1, magic2));
37 }
38 debug!("✓ Valid magic bytes (JX)");
39
40 let version = self.reader.read_u32_le()?;
42 debug!("Version: {}", version);
43
44 if version > 1 {
45 return Err(ParserError::UnsupportedVersion(version));
46 }
47
48 let target_engine = self.reader.read_cstring()?;
50 debug!("Target engine: {}", target_engine);
51
52 let string_count = self.reader.read_u32_le()? as usize;
54 debug!("Reading {} strings", string_count);
55
56 self.string_table.clear();
57 for i in 0..string_count {
58 let str_len = self.reader.read_u32_le()? as usize;
59 let string = self.reader.read_string(str_len)?;
60 trace!("String[{}]: {}", i, string);
61 self.string_table.push(string);
62 }
63 debug!("✓ String table loaded");
64
65 let mut tokens = Vec::new();
67 while !self.reader.is_eof() {
68 match self.parse_token() {
69 Ok(token) => {
70 if let Token::Unknown(_) = token {
71 trace!("Skipping unknown token at offset {}", self.reader.position());
73 }
74 tokens.push(token);
75 }
76 Err(e) => {
77 log::warn!("Error parsing token: {}", e);
78 break;
79 }
80 }
81 }
82 debug!("✓ Parsed {} tokens", tokens.len());
83
84 let parse_time_ms = start.elapsed().as_millis() as u64;
85
86 let metadata = FileMetadata {
87 file_size: self.reader.len(),
88 parse_time_ms,
89 token_count: tokens.len(),
90 string_count,
91 };
92
93 Ok(JsxBinFile {
94 version,
95 target_engine,
96 string_table: self.string_table.clone(),
97 tokens,
98 metadata,
99 })
100 }
101
102 fn parse_token(&mut self) -> ParserResult<Token> {
104 let opcode_byte = self.reader.read_u8()?;
105
106 if let Some(opcode) = Opcode::from_byte(opcode_byte) {
107 trace!("Parsing opcode: {:?} (0x{:02x})", opcode, opcode_byte);
108
109 match opcode {
110 Opcode::EndOfStatement => Ok(Token::Block(Block {
111 statements: Vec::new(),
112 })),
113
114 Opcode::Null => Ok(Token::Null),
115
116 Opcode::Undefined => Ok(Token::Undefined),
117
118 Opcode::Number => {
119 let value = self.reader.read_f64_le()?;
120 Ok(Token::NumberLiteral(value))
121 }
122
123 Opcode::String => {
124 let index = self.reader.read_u32_le()? as usize;
125 if index >= self.string_table.len() {
126 return Err(ParserError::InvalidStringIndex(index));
127 }
128 Ok(Token::StringLiteral(self.string_table[index].clone()))
129 }
130
131 Opcode::Boolean => {
132 let value = self.reader.read_u8()? != 0;
133 Ok(Token::BooleanLiteral(value))
134 }
135
136 Opcode::Identifier => {
137 let index = self.reader.read_u32_le()? as usize;
138 if index >= self.string_table.len() {
139 return Err(ParserError::InvalidStringIndex(index));
140 }
141 Ok(Token::Identifier(self.string_table[index].clone()))
142 }
143
144 Opcode::Function => {
145 let name_index = self.reader.read_u32_le()? as usize;
146 let name = if name_index < self.string_table.len() {
147 self.string_table[name_index].clone()
148 } else {
149 format!("function_{}", name_index)
150 };
151
152 let param_count = self.reader.read_u32_le()? as usize;
153 let mut params = Vec::new();
154 for _ in 0..param_count {
155 let param_index = self.reader.read_u32_le()? as usize;
156 if param_index < self.string_table.len() {
157 params.push(self.string_table[param_index].clone());
158 }
159 }
160
161 let body = Box::new(Block {
163 statements: Vec::new(),
164 });
165
166 Ok(Token::Function { name, params, body })
167 }
168
169 Opcode::Return => {
170 Ok(Token::ReturnStatement(None))
172 }
173
174 Opcode::If => {
175 Ok(Token::IfStatement {
177 condition: Box::new(Token::BooleanLiteral(true).into()),
178 consequent: Box::new(Block {
179 statements: Vec::new(),
180 }),
181 alternate: None,
182 })
183 }
184
185 Opcode::While => {
186 Ok(Token::WhileLoop {
188 condition: Box::new(Token::BooleanLiteral(true).into()),
189 body: Box::new(Block {
190 statements: Vec::new(),
191 }),
192 })
193 }
194
195 Opcode::Break => Ok(Token::BreakStatement),
196
197 Opcode::Continue => Ok(Token::ContinueStatement),
198
199 Opcode::Plus => {
200 Ok(Token::Identifier("+".to_string()))
202 }
203
204 _ => {
205 let raw = vec![opcode_byte];
206 Ok(Token::Unknown(raw))
207 }
208 }
209 } else {
210 let raw = vec![opcode_byte];
211 Ok(Token::Unknown(raw))
212 }
213 }
214}
215
216#[cfg(test)]
217mod tests {
218 use super::*;
219
220 #[test]
221 fn test_invalid_magic() {
222 let data = vec![0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00];
223 let mut parser = JsxbinParser::new(data);
224 assert!(parser.parse().is_err());
225 }
226
227 #[test]
228 fn test_valid_header() {
229 let mut data = vec![
230 0x4A, 0x58, 0x01, 0x00, 0x00, 0x00, ];
233 data.extend_from_slice(b"ExtendScript\0");
235 data.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); let mut parser = JsxbinParser::new(data);
239 let result = parser.parse();
240 assert!(result.is_ok());
241 if let Ok(file) = result {
242 assert_eq!(file.version, 1);
243 }
244 }
245}