Skip to main content

jsxbin_parser/
parser.rs

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
7/// Main JSXBIN file parser
8pub struct JsxbinParser {
9    reader: BinaryReader,
10    string_table: Vec<String>,
11    offset: usize,
12}
13
14impl JsxbinParser {
15    /// Create a new parser from binary data
16    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    /// Parse the JSXBIN file
26    pub fn parse(&mut self) -> ParserResult<JsxBinFile> {
27        let start = Instant::now();
28        debug!("Starting JSXBIN parsing");
29
30        // Read and validate magic bytes
31        let magic1 = self.reader.read_u8()?;
32        let magic2 = self.reader.read_u8()?;
33
34        if magic1 != 0x4A || magic2 != 0x58 {
35            // 0x4A = 'J', 0x58 = 'X'
36            return Err(ParserError::InvalidMagic(magic1, magic2));
37        }
38        debug!("✓ Valid magic bytes (JX)");
39
40        // Read version
41        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        // Read target engine (null-terminated string)
49        let target_engine = self.reader.read_cstring()?;
50        debug!("Target engine: {}", target_engine);
51
52        // Read string table
53        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        // Parse token stream
66        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                        // Skip unknown tokens
72                        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    /// Parse a single token
103    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                    // TODO: Parse function body
162                    let body = Box::new(Block {
163                        statements: Vec::new(),
164                    });
165
166                    Ok(Token::Function { name, params, body })
167                }
168
169                Opcode::Return => {
170                    // TODO: Parse return value
171                    Ok(Token::ReturnStatement(None))
172                }
173
174                Opcode::If => {
175                    // TODO: Parse if condition and branches
176                    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                    // TODO: Parse while loop
187                    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                    // Binary operation - requires operands
201                    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, // Magic "JX"
231            0x01, 0x00, 0x00, 0x00, // Version 1
232        ];
233        // Add null-terminated engine string
234        data.extend_from_slice(b"ExtendScript\0");
235        // Add empty string table
236        data.extend_from_slice(&[0x00, 0x00, 0x00, 0x00]); // 0 strings
237
238        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}