hornvale/scripting_language/parser/
mod.rs

1use std::mem::replace;
2
3use crate::scripting_language::class_compiler::ClassCompiler;
4use crate::scripting_language::compiler::function_type::FunctionType;
5use crate::scripting_language::compiler::Compiler;
6use crate::scripting_language::function::Function;
7use crate::scripting_language::garbage_collection::collector::Collector as GarbageCollector;
8use crate::scripting_language::garbage_collection::reference::Reference;
9use crate::scripting_language::instruction::Instruction;
10use crate::scripting_language::local::Local;
11use crate::scripting_language::scanner::Scanner;
12use crate::scripting_language::token::r#type::Type as TokenType;
13use crate::scripting_language::token::Token;
14use crate::scripting_language::value::Value;
15
16pub mod error;
17use error::Error;
18pub mod precedence;
19use precedence::Precedence;
20pub mod rule;
21use rule::Rule;
22pub mod rules;
23use rules::Rules;
24
25/// The `Parser` type.
26#[derive(Debug, Display)]
27#[display(
28  fmt = "scanner: {}, current: {:#?}, previous: {:#?}, rules: {}, suppress_new_errors: {}, did_encounter_error: {:#?}",
29  scanner,
30  current,
31  previous,
32  rules,
33  suppress_new_errors,
34  did_encounter_error
35)]
36pub struct Parser<'source> {
37  /// The scanner.
38  pub scanner: Scanner<'source>,
39  /// The garbage collector.
40  pub garbage_collector: &'source mut GarbageCollector,
41  /// The compiler for the current scope.
42  pub compiler: Box<Compiler<'source>>,
43  /// The class compiler.
44  pub class_compiler: Option<Box<ClassCompiler>>,
45  /// The current token.
46  pub current: Option<Token<'source>>,
47  /// The last token processed.
48  pub previous: Option<Token<'source>>,
49  /// The rules!
50  pub rules: Rules<'source>,
51  /// Whether we should suppress new errors ("Panic Mode").
52  pub suppress_new_errors: bool,
53  /// Whether we have actually encountered an error.
54  pub did_encounter_error: bool,
55  /// Errors that arise in the process of resolving locals and upvalues.
56  pub resolver_errors: Vec<&'static str>,
57}
58
59impl<'source> Parser<'source> {
60  /// Constructor.
61  #[named]
62  pub fn new(scanner: Scanner<'source>, garbage_collector: &'source mut GarbageCollector) -> Parser<'source> {
63    trace_enter!();
64    trace_var!(scanner);
65    trace_var!(garbage_collector);
66    let current = None;
67    trace_var!(current);
68    let previous = None;
69    trace_var!(previous);
70    let function_name = garbage_collector.intern("script".to_owned());
71    trace_var!(function_name);
72    let compiler = Box::new(Compiler::new(function_name, FunctionType::Script));
73    trace_var!(compiler);
74    let rules = Rules::default();
75    trace_var!(rules);
76    let suppress_new_errors = false;
77    trace_var!(suppress_new_errors);
78    let did_encounter_error = false;
79    trace_var!(did_encounter_error);
80    let resolver_errors = Vec::new();
81    trace_var!(resolver_errors);
82    let class_compiler = None;
83    trace_var!(class_compiler);
84    let result = Self {
85      scanner,
86      garbage_collector,
87      compiler,
88      current,
89      previous,
90      rules,
91      suppress_new_errors,
92      did_encounter_error,
93      resolver_errors,
94      class_compiler,
95    };
96    trace_var!(result);
97    trace_exit!();
98    result
99  }
100
101  /// Compile!
102  #[named]
103  pub fn compile(mut self) -> Result<Reference<Function>, Error> {
104    trace_enter!();
105    self.advance()?;
106    let mut first_error = None;
107    while !self.r#match(TokenType::Eof)? {
108      if let (None, Err(error)) = (&first_error, self.parse_declaration()) {
109        first_error = Some(error);
110      }
111    }
112    self.emit_return()?;
113    let result = match self.did_encounter_error {
114      false => Ok(self.garbage_collector.alloc(self.compiler.function)),
115      true => Err(first_error.unwrap_or(Error::UnknownError)),
116    };
117    trace_var!(result);
118    trace_exit!();
119    result
120  }
121
122  /// Advance!
123  #[named]
124  pub fn advance(&mut self) -> Result<(), Error> {
125    trace_enter!();
126    self.previous = self.current;
127    loop {
128      self.current = Some(self.scanner.scan_token()?);
129      if let TokenType::Error = self.current.unwrap().r#type {
130        self.did_encounter_error_at_current(self.current.unwrap().lexeme);
131      } else {
132        break;
133      }
134    }
135    Ok(())
136  }
137
138  /// Consume.
139  #[named]
140  pub fn consume(&mut self, expected: TokenType, message: &str) -> Result<(), Error> {
141    trace_enter!();
142    trace_var!(expected);
143    trace_var!(message);
144    let current_type = self.current.unwrap().r#type;
145    trace_var!(current_type);
146    let result = if current_type == expected {
147      self.advance()?;
148      Ok(())
149    } else {
150      self.did_encounter_error_at_current(message);
151      Err(Error::UnexpectedTokenError(current_type, message.to_string()))
152    };
153    trace_exit!();
154    result
155  }
156
157  /// Grouping.
158  #[named]
159  pub fn parse_grouping(&mut self, _can_assign: bool) -> Result<(), Error> {
160    trace_enter!();
161    self.parse_expression()?;
162    self.consume(TokenType::RightParenthesis, "expected ')' after expression")?;
163    trace_exit!();
164    Ok(())
165  }
166
167  /// Declaration.
168  #[named]
169  pub fn parse_declaration(&mut self) -> Result<(), Error> {
170    trace_enter!();
171    if self.r#match(TokenType::Class)? {
172      self.parse_class_declaration()?;
173    } else if self.r#match(TokenType::Function)? {
174      self.parse_function_declaration()?;
175    } else if self.r#match(TokenType::Var)? {
176      self.parse_variable_declaration()?;
177    } else {
178      self.parse_statement()?;
179    }
180    if self.suppress_new_errors {
181      self.synchronize()?;
182    }
183    trace_exit!();
184    Ok(())
185  }
186
187  /// Class declaration.
188  #[named]
189  pub fn parse_class_declaration(&mut self) -> Result<(), Error> {
190    trace_enter!();
191    self.consume(TokenType::Identifier, "Expect class name.")?;
192    let class_name = self.previous.unwrap();
193    trace_var!(class_name);
194    let name_constant = self.get_identifier_constant(class_name)?;
195    trace_var!(name_constant);
196    self.declare_variable()?;
197    self.emit_instruction(Instruction::Class(name_constant))?;
198    self.define_variable(name_constant)?;
199    let old_class_compiler = self.class_compiler.take();
200    let new_class_compiler = ClassCompiler::new(old_class_compiler);
201    self.class_compiler.replace(new_class_compiler);
202    if self.r#match(TokenType::LessThan)? {
203      self.consume(TokenType::Identifier, "Expect superclass name.")?;
204      self.parse_variable(false)?;
205      if class_name.lexeme == self.previous.unwrap().lexeme {
206        self.did_encounter_error("A class can't inherit from itself.");
207        return Err(Error::AttemptedToDeclareClassAsASubclassOfItself);
208      }
209      self.begin_scope()?;
210      self.add_local(Token::synthesize("super"))?;
211      self.define_variable(0)?;
212      self.did_name_variable(class_name, false)?;
213      self.emit_instruction(Instruction::Inherit)?;
214      self.class_compiler.as_mut().unwrap().has_superclass = true;
215    }
216    self.did_name_variable(class_name, false)?;
217    self.consume(TokenType::LeftBrace, "Expect '{' before class body.")?;
218    while !self.check(TokenType::RightBrace) && !self.check(TokenType::Eof) {
219      self.parse_method_declaration()?;
220    }
221    self.consume(TokenType::RightBrace, "Expect '}' after class body.")?;
222    self.emit_instruction(Instruction::Pop)?;
223    if self.class_compiler.as_ref().unwrap().has_superclass {
224      self.end_scope()?;
225    }
226    match self.class_compiler.take() {
227      Some(class_compiler) => self.class_compiler = class_compiler.enclosing,
228      None => self.class_compiler = None,
229    }
230    trace_exit!();
231    Ok(())
232  }
233
234  /// Method declaration.
235  #[named]
236  pub fn parse_method_declaration(&mut self) -> Result<(), Error> {
237    trace_enter!();
238    self.consume(TokenType::Identifier, "Expect method name.")?;
239    let constant = self.get_identifier_constant(self.previous.unwrap())?;
240    trace_var!(constant);
241    let function_type = if self.previous.unwrap().lexeme == "init" {
242      FunctionType::Initializer
243    } else {
244      FunctionType::Method
245    };
246    self.parse_function(function_type)?;
247    self.emit_instruction(Instruction::Method(constant))?;
248    trace_exit!();
249    Ok(())
250  }
251
252  /// Function declaration.
253  #[named]
254  pub fn parse_function_declaration(&mut self) -> Result<(), Error> {
255    trace_enter!();
256    let function_index = self.parse_variable_identifier("expected a function name")?;
257    trace_var!(function_index);
258    self.mark_initialized()?;
259    self.parse_function(FunctionType::Function)?;
260    self.define_variable(function_index)?;
261    trace_exit!();
262    Ok(())
263  }
264
265  /// Variable declaration.
266  #[named]
267  pub fn parse_variable_declaration(&mut self) -> Result<(), Error> {
268    trace_enter!();
269    let variable_index = self.parse_variable_identifier("Expect variable name.")?;
270    trace_var!(variable_index);
271    if self.r#match(TokenType::Equal)? {
272      self.parse_expression()?;
273    } else {
274      self.emit_instruction(Instruction::Nil)?;
275    }
276    self.consume(TokenType::Semicolon, "expected ';' after variable declaration")?;
277    self.define_variable(variable_index)?;
278    trace_exit!();
279    Ok(())
280  }
281
282  /// Statement.
283  #[named]
284  pub fn parse_statement(&mut self) -> Result<(), Error> {
285    trace_enter!();
286    if self.r#match(TokenType::Print)? {
287      self.parse_print_statement()?;
288    } else if self.r#match(TokenType::If)? {
289      self.parse_if_statement()?;
290    } else if self.r#match(TokenType::Return)? {
291      self.parse_return_statement()?;
292    } else if self.r#match(TokenType::While)? {
293      self.parse_while_statement()?;
294    } else if self.r#match(TokenType::For)? {
295      self.parse_for_statement()?;
296    } else if self.r#match(TokenType::LeftBrace)? {
297      self.begin_scope()?;
298      self.parse_block()?;
299      self.end_scope()?;
300    } else {
301      self.parse_expression_statement()?;
302    }
303    trace_exit!();
304    Ok(())
305  }
306
307  /// Begin a scope.
308  #[named]
309  pub fn begin_scope(&mut self) -> Result<(), Error> {
310    trace_enter!();
311    self.compiler.depth += 1;
312    trace_exit!();
313    Ok(())
314  }
315
316  /// Function.
317  #[named]
318  pub fn parse_function(&mut self, function_type: FunctionType) -> Result<(), Error> {
319    trace_enter!();
320    self.push_compiler(function_type)?;
321    self.begin_scope()?;
322    self.consume(TokenType::LeftParenthesis, "expected '(' after function name.")?;
323    if !self.check(TokenType::RightParenthesis) {
324      loop {
325        self.compiler.function.arity += 1;
326        if self.compiler.function.arity > 255 {
327          self.did_encounter_error_at_current("Can't have more than 255 parameters.");
328          return Err(Error::FunctionArityExceededLimit);
329        }
330        let parameter = self.parse_variable_identifier("expected a parameter identifier")?;
331        self.define_variable(parameter)?;
332        if !self.r#match(TokenType::Comma)? {
333          break;
334        }
335      }
336    }
337    self.consume(TokenType::RightParenthesis, "Expect ')' after parameters.")?;
338    self.consume(TokenType::LeftBrace, "Expect '{' before function body.")?;
339    self.parse_block()?;
340    let function = self.pop_compiler()?;
341    let function_id = self.garbage_collector.alloc(function);
342    let index = self.make_constant(Value::Function(function_id))?;
343    self.emit_instruction(Instruction::Closure(index))?;
344    trace_exit!();
345    Ok(())
346  }
347
348  /// Encountered an error at the previous token.
349  #[named]
350  pub fn did_encounter_error(&mut self, message: &str) {
351    trace_enter!();
352    trace_var!(message);
353    self.did_encounter_error_at_token(self.previous.unwrap(), message);
354    trace_exit!();
355  }
356
357  /// Encountered an error at the current token.
358  #[named]
359  pub fn did_encounter_error_at_current(&mut self, message: &str) {
360    trace_enter!();
361    trace_var!(message);
362    self.did_encounter_error_at_token(self.current.unwrap(), message);
363    trace_exit!();
364  }
365
366  /// Encountered an error.
367  #[named]
368  pub fn did_encounter_error_at_token(&mut self, token: Token, message: &str) {
369    trace_enter!();
370    trace_var!(token);
371    trace_var!(message);
372    if self.suppress_new_errors {
373      return;
374    }
375    self.did_encounter_error = true;
376    self.suppress_new_errors = true;
377    eprint!("[line {}] Error", token.line_number);
378    use TokenType::*;
379    match token.r#type {
380      Error => (),
381      Eof => eprint!(" at end"),
382      _ => eprint!(" at '{}'", token.lexeme),
383    };
384    eprintln!(": {}", message);
385    trace_exit!();
386  }
387
388  /// Block.
389  #[named]
390  pub fn parse_block(&mut self) -> Result<(), Error> {
391    trace_enter!();
392    while !self.check(TokenType::RightBrace) && !self.check(TokenType::Eof) {
393      self.parse_declaration()?;
394    }
395    self.consume(TokenType::RightBrace, "expected '}' after block")?;
396    trace_exit!();
397    Ok(())
398  }
399
400  /// Parse `super`.
401  #[named]
402  pub fn parse_super(&mut self, can_assign: bool) -> Result<(), Error> {
403    trace_enter!();
404    trace_var!(can_assign);
405    if let Some(current_class) = self.class_compiler.as_ref() {
406      if !current_class.has_superclass {
407        self.did_encounter_error("Can't use 'super' in a class with no superclass.");
408        return Err(Error::AttemptedToUseSuperInBaseClass);
409      }
410    } else {
411      self.did_encounter_error("Can't use 'super' outside of a class.");
412      return Err(Error::AttemptedToUseSuperOutsideClass);
413    }
414    self.consume(TokenType::Dot, "Expect '.' after 'super'.")?;
415    self.consume(TokenType::Identifier, "Expect superclass method name.")?;
416    let name = self.get_identifier_constant(self.previous.unwrap())?;
417    self.did_name_variable(Token::synthesize("this"), false)?;
418    if self.r#match(TokenType::LeftParenthesis)? {
419      let argument_count = self.parse_argument_list()?;
420      self.did_name_variable(Token::synthesize("super"), false)?;
421      self.emit_instruction(Instruction::SuperInvoke((name, argument_count)))?;
422    } else {
423      self.did_name_variable(Token::synthesize("super"), false)?;
424      self.emit_instruction(Instruction::GetSuper(name))?;
425    }
426    trace_exit!();
427    Ok(())
428  }
429
430  /// Dots for method calls, etc.
431  #[named]
432  pub fn parse_dot(&mut self, can_assign: bool) -> Result<(), Error> {
433    trace_enter!();
434    trace_var!(can_assign);
435    self.consume(TokenType::Identifier, "Expect property name after '.'.")?;
436    let name = self.get_identifier_constant(self.previous.unwrap())?;
437    if can_assign && self.r#match(TokenType::Equal)? {
438      self.parse_expression()?;
439      self.emit_instruction(Instruction::SetProperty(name))?;
440    } else if self.r#match(TokenType::LeftParenthesis)? {
441      let argument_count = self.parse_argument_list()?;
442      self.emit_instruction(Instruction::Invoke((name, argument_count)))?;
443    } else {
444      self.emit_instruction(Instruction::GetProperty(name))?;
445    }
446    trace_exit!();
447    Ok(())
448  }
449
450  /// Parse `this`.
451  #[named]
452  pub fn parse_this(&mut self, can_assign: bool) -> Result<(), Error> {
453    trace_enter!();
454    trace_var!(can_assign);
455    if self.class_compiler.is_none() {
456      self.did_encounter_error("Can't use 'this' outside of a class.");
457      return Err(Error::AttemptedToUseThisOutsideClass);
458    }
459    self.parse_variable(false)?;
460    trace_exit!();
461    Ok(())
462  }
463
464  /// End a scope.
465  #[named]
466  pub fn end_scope(&mut self) -> Result<(), Error> {
467    trace_enter!();
468    self.compiler.depth -= 1;
469    for i in (0..self.compiler.locals.len()).rev() {
470      if self.compiler.locals[i].depth > self.compiler.depth {
471        if self.compiler.locals[i].is_captured {
472          self.emit_instruction(Instruction::CloseUpvalue)?;
473        } else {
474          self.emit_instruction(Instruction::Pop)?;
475        }
476        self.compiler.locals.pop();
477      }
478    }
479    trace_exit!();
480    Ok(())
481  }
482
483  /// Print statement.
484  #[named]
485  pub fn parse_print_statement(&mut self) -> Result<(), Error> {
486    trace_enter!();
487    self.parse_expression()?;
488    self.consume(TokenType::Semicolon, "Expect ';' after expression.")?;
489    self.emit_instruction(Instruction::Print)?;
490    trace_exit!();
491    Ok(())
492  }
493
494  /// If statement.
495  #[named]
496  pub fn parse_if_statement(&mut self) -> Result<(), Error> {
497    trace_enter!();
498    self.r#match(TokenType::LeftParenthesis)?;
499    self.parse_expression()?;
500    self.r#match(TokenType::RightParenthesis)?;
501    let then_jump = self.compiler.function.chunk.instructions.instructions.len();
502    self.emit_instruction(Instruction::JumpIfFalse(u16::MAX))?;
503    self.emit_instruction(Instruction::Pop)?;
504    self.parse_statement()?;
505    let else_jump = self.compiler.function.chunk.instructions.instructions.len();
506    self.emit_instruction(Instruction::Jump(u16::MAX))?;
507    self.patch_jump(then_jump as u16)?;
508    self.emit_instruction(Instruction::Pop)?;
509    if self.r#match(TokenType::Else)? {
510      self.parse_statement()?;
511    }
512    self.patch_jump(else_jump as u16)?;
513    trace_exit!();
514    Ok(())
515  }
516
517  /// Return statement.
518  #[named]
519  pub fn parse_return_statement(&mut self) -> Result<(), Error> {
520    trace_enter!();
521    if let FunctionType::Script = self.compiler.function_type {
522      // Not going to block `return` in top-level code ATM.
523      self.did_encounter_error("Can't return from top-level code.");
524    } else if self.r#match(TokenType::Semicolon)? {
525      self.emit_return()?;
526    } else {
527      if let FunctionType::Initializer = self.compiler.function_type {
528        self.did_encounter_error("Can't return a value from an initializer.");
529      }
530      self.parse_expression()?;
531      self.consume(TokenType::Semicolon, "expected ';' after return value")?;
532      self.emit_instruction(Instruction::Return)?;
533    }
534    trace_exit!();
535    Ok(())
536  }
537
538  /// Patch the jump statement.
539  ///
540  /// We're provided with the `index`, which is the location in code of the
541  /// instruction to patch. We also have the current length of the code,
542  /// which indicates how many instructions have been added since then.
543  /// So we should take the difference of the two indices and add one so that
544  /// we jump cleanly to the next instruction.
545  #[named]
546  pub fn patch_jump(&mut self, index: u16) -> Result<(), Error> {
547    trace_enter!();
548    trace_var!(index);
549    let latest = self.compiler.function.chunk.instructions.instructions.len() as u16 - 1;
550    trace_var!(latest);
551    let offset = latest - index;
552    trace_var!(offset);
553    match self.compiler.function.chunk.instructions.instructions[index as usize] {
554      Instruction::JumpIfFalse(ref mut dest) => *dest = offset,
555      Instruction::Jump(ref mut dest) => *dest = offset,
556      instruction => panic!("Incorrect instruction {:#?} at position", instruction),
557    };
558    trace_exit!();
559    Ok(())
560  }
561
562  /// While statement.
563  #[named]
564  pub fn parse_while_statement(&mut self) -> Result<(), Error> {
565    trace_enter!();
566    let loop_start = self.compiler.function.chunk.instructions.instructions.len();
567    self.r#match(TokenType::LeftParenthesis)?;
568    self.parse_expression()?;
569    self.r#match(TokenType::RightParenthesis)?;
570    let exit_jump = self.compiler.function.chunk.instructions.instructions.len();
571    self.emit_instruction(Instruction::JumpIfFalse(u16::MAX))?;
572    self.emit_instruction(Instruction::Pop)?;
573    self.parse_statement()?;
574    self.emit_loop(loop_start as u16)?;
575    self.patch_jump(exit_jump as u16)?;
576    self.emit_instruction(Instruction::Pop)?;
577    trace_exit!();
578    Ok(())
579  }
580
581  /// Emit a loop instruction.
582  ///
583  /// We're provided with the `index`, which is the location in code of the
584  /// instruction to patch. We also have the current length of the code,
585  /// which indicates how many instructions have been added since then.
586  /// So we should take the difference of the two indices so that we jump back
587  /// to when the condition is checked.
588  #[named]
589  pub fn emit_loop(&mut self, index: u16) -> Result<(), Error> {
590    trace_enter!();
591    trace_var!(index);
592    let latest = self.compiler.function.chunk.instructions.instructions.len() as u16 - 1;
593    trace_var!(latest);
594    let offset = (latest - index) + 2;
595    trace_var!(offset);
596    self.emit_instruction(Instruction::Loop(offset))?;
597    trace_exit!();
598    Ok(())
599  }
600
601  /// Parse a function call.
602  #[named]
603  pub fn parse_call(&mut self, can_assign: bool) -> Result<(), Error> {
604    trace_enter!();
605    trace_var!(can_assign);
606    let argument_count = self.parse_argument_list()?;
607    trace_var!(argument_count);
608    self.emit_instruction(Instruction::Call(argument_count))?;
609    trace_exit!();
610    Ok(())
611  }
612
613  /// Parse the argument length.
614  #[named]
615  pub fn parse_argument_list(&mut self) -> Result<u8, Error> {
616    trace_enter!();
617    let mut count: usize = 0;
618    trace_var!(count);
619    if !self.check(TokenType::RightParenthesis) {
620      loop {
621        self.parse_expression()?;
622        if count == 255 {
623          self.did_encounter_error("Can't have more than 255 arguments.");
624          return Err(Error::FunctionCallArgumentsExceededLimit);
625        }
626        count += 1;
627        if !self.r#match(TokenType::Comma)? {
628          break;
629        }
630      }
631    }
632    self.consume(TokenType::RightParenthesis, "expected ')' after call arguments")?;
633    let result = count as u8;
634    trace_var!(result);
635    trace_exit!();
636    Ok(result)
637  }
638
639  /// For statement.
640  #[named]
641  pub fn parse_for_statement(&mut self) -> Result<(), Error> {
642    trace_enter!();
643    self.begin_scope()?;
644    self.consume(TokenType::LeftParenthesis, "expected '(' after 'for'.")?;
645
646    // Process initializer segment.
647    if self.r#match(TokenType::Semicolon)? {
648      // No initializer, no problem.
649    } else if self.r#match(TokenType::Var)? {
650      self.parse_variable_declaration()?;
651    } else {
652      self.parse_expression_statement()?;
653    }
654
655    let mut loop_start = self.compiler.function.chunk.instructions.instructions.len();
656
657    // Process condition segment.
658    let mut exit_jump: Option<usize> = None;
659    if !self.r#match(TokenType::Semicolon)? {
660      self.parse_expression()?;
661      self.consume(TokenType::Semicolon, "expected ';' after loop condition.")?;
662      exit_jump = Some(self.compiler.function.chunk.instructions.instructions.len());
663      self.emit_instruction(Instruction::JumpIfFalse(0xFFFF))?;
664      self.emit_instruction(Instruction::Pop)?;
665    }
666
667    // Process increment segment.
668    if !self.r#match(TokenType::RightParenthesis)? {
669      let body_jump = self.compiler.function.chunk.instructions.instructions.len();
670      self.emit_instruction(Instruction::Jump(0xFFFF))?;
671      let increment_start = self.compiler.function.chunk.instructions.instructions.len();
672      self.parse_expression()?;
673      self.emit_instruction(Instruction::Pop)?;
674      self.consume(TokenType::RightParenthesis, "expected ')' after 'for' clauses.")?;
675      self.emit_loop(loop_start as u16)?;
676      loop_start = increment_start;
677      self.patch_jump(body_jump as u16)?;
678    }
679    // Loop!
680    self.parse_statement()?;
681    self.emit_loop(loop_start as u16)?;
682    if let Some(exit_jump) = exit_jump {
683      self.patch_jump(exit_jump as u16)?;
684      self.emit_instruction(Instruction::Pop)?;
685    }
686    self.end_scope()?;
687    trace_exit!();
688    Ok(())
689  }
690
691  /// Expression statement.
692  #[named]
693  pub fn parse_expression_statement(&mut self) -> Result<(), Error> {
694    trace_enter!();
695    self.parse_expression()?;
696    self.consume(TokenType::Semicolon, "Expect ';' after expression.")?;
697    self.emit_instruction(Instruction::Pop)?;
698    trace_exit!();
699    Ok(())
700  }
701
702  /// Expression.
703  #[named]
704  pub fn parse_expression(&mut self) -> Result<(), Error> {
705    trace_enter!();
706    self.parse_precedence(Precedence::Assignment)?;
707    trace_exit!();
708    Ok(())
709  }
710
711  /// A number!
712  #[named]
713  #[inline]
714  pub fn parse_number(&mut self, _can_assign: bool) -> Result<(), Error> {
715    trace_enter!();
716    let previous = self.previous.unwrap();
717    trace_var!(previous);
718    let string = previous.lexeme;
719    trace_var!(string);
720    let value = string.parse::<f64>()?;
721    trace_var!(value);
722    self.emit_constant(Value::Number(value))?;
723    trace_exit!();
724    Ok(())
725  }
726
727  /// A string!
728  #[named]
729  #[inline]
730  pub fn parse_string(&mut self, _can_assign: bool) -> Result<(), Error> {
731    trace_enter!();
732    let previous = self.previous.unwrap();
733    trace_var!(previous);
734    let string = &previous.lexeme[1..(previous.lexeme.len() - 1)];
735    trace_var!(string);
736    let value = self.garbage_collector.intern(string.to_owned());
737    trace_var!(value);
738    self.emit_constant(Value::String(value))?;
739    trace_exit!();
740    Ok(())
741  }
742
743  /// Intern a string from the source.
744  #[named]
745  #[inline]
746  pub fn intern_token(&mut self, token: &Token) -> Result<Reference<String>, Error> {
747    trace_enter!();
748    let string = token.lexeme;
749    trace_var!(string);
750    let result = self.garbage_collector.intern(string.to_owned());
751    trace_var!(result);
752    trace_exit!();
753    Ok(result)
754  }
755
756  /// Parse a variable.
757  #[named]
758  pub fn parse_variable(&mut self, can_assign: bool) -> Result<(), Error> {
759    trace_enter!();
760    self.did_name_variable(self.previous.unwrap(), can_assign)?;
761    trace_exit!();
762    Ok(())
763  }
764
765  /// Parse an And.
766  #[named]
767  pub fn parse_and(&mut self, _can_assign: bool) -> Result<(), Error> {
768    trace_enter!();
769    let end_jump = self.compiler.function.chunk.instructions.instructions.len();
770    self.emit_instruction(Instruction::JumpIfFalse(u16::MAX))?;
771    self.emit_instruction(Instruction::Pop)?;
772    self.parse_precedence(Precedence::And)?;
773    self.patch_jump(end_jump as u16)?;
774    trace_exit!();
775    Ok(())
776  }
777
778  /// Parse an Or.
779  #[named]
780  pub fn parse_or(&mut self, _can_assign: bool) -> Result<(), Error> {
781    trace_enter!();
782    let else_jump = self.compiler.function.chunk.instructions.instructions.len();
783    self.emit_instruction(Instruction::JumpIfFalse(u16::MAX))?;
784    let end_jump = self.compiler.function.chunk.instructions.instructions.len();
785    self.emit_instruction(Instruction::Jump(u16::MAX))?;
786    self.patch_jump(else_jump as u16)?;
787    self.emit_instruction(Instruction::Pop)?;
788    self.parse_precedence(Precedence::Or)?;
789    self.patch_jump(end_jump as u16)?;
790    trace_exit!();
791    Ok(())
792  }
793
794  /// Parse a variable identifier.
795  #[named]
796  pub fn parse_variable_identifier(&mut self, message: &str) -> Result<u16, Error> {
797    trace_enter!();
798    self.consume(TokenType::Identifier, message)?;
799    self.declare_variable()?;
800    if self.compiler.depth > 0 {
801      return Ok(0);
802    }
803    let result = self.get_identifier_constant(self.previous.unwrap())?;
804    trace_var!(result);
805    trace_exit!();
806    Ok(result)
807  }
808
809  /// Binary operator.
810  #[named]
811  pub fn parse_binary(&mut self, _can_assign: bool) -> Result<(), Error> {
812    trace_enter!();
813    let operator_type = self.previous.unwrap().r#type;
814    let rule = self.get_rule(&operator_type);
815    self.parse_precedence(rule.unwrap().precedence.next())?;
816    use TokenType::*;
817    match operator_type {
818      BangEqual => self.emit_instruction(Instruction::NotEqual)?,
819      EqualEqual => self.emit_instruction(Instruction::Equal)?,
820      GreaterThan => self.emit_instruction(Instruction::GreaterThan)?,
821      GreaterThanOrEqual => self.emit_instruction(Instruction::GreaterThanOrEqual)?,
822      LessThan => self.emit_instruction(Instruction::LessThan)?,
823      LessThanOrEqual => self.emit_instruction(Instruction::LessThanOrEqual)?,
824      Plus => self.emit_instruction(Instruction::Add)?,
825      Minus => self.emit_instruction(Instruction::Subtract)?,
826      Star => self.emit_instruction(Instruction::Multiply)?,
827      Slash => self.emit_instruction(Instruction::Divide)?,
828      _ => {},
829    }
830    trace_exit!();
831    Ok(())
832  }
833
834  /// Unary operator.
835  #[named]
836  pub fn parse_unary(&mut self, _can_assign: bool) -> Result<(), Error> {
837    trace_enter!();
838    let operator_type = self.previous.unwrap().r#type;
839    self.parse_precedence(Precedence::Unary)?;
840    use TokenType::*;
841    match operator_type {
842      Minus => self.emit_instruction(Instruction::Negate)?,
843      Bang => self.emit_instruction(Instruction::Not)?,
844      _ => {},
845    }
846    trace_exit!();
847    Ok(())
848  }
849
850  /// Literal.
851  #[named]
852  pub fn parse_literal(&mut self, _can_assign: bool) -> Result<(), Error> {
853    trace_enter!();
854    let token_type = self.previous.unwrap().r#type;
855    use TokenType::*;
856    match token_type {
857      True => self.emit_instruction(Instruction::True)?,
858      False => self.emit_instruction(Instruction::False)?,
859      Nil => self.emit_instruction(Instruction::Nil)?,
860      _ => {},
861    }
862    trace_exit!();
863    Ok(())
864  }
865
866  /// Rejoin society.
867  #[named]
868  pub fn synchronize(&mut self) -> Result<(), Error> {
869    trace_enter!();
870    self.suppress_new_errors = false;
871    while self.previous.unwrap().r#type != TokenType::Eof {
872      if self.previous.unwrap().r#type == TokenType::Semicolon {
873        return Ok(());
874      }
875      match self.current.unwrap().r#type {
876        TokenType::Class
877        | TokenType::Function
878        | TokenType::Var
879        | TokenType::For
880        | TokenType::If
881        | TokenType::While
882        | TokenType::Print
883        | TokenType::Return => return Ok(()),
884        _ => (),
885      }
886      self.advance()?;
887    }
888    trace_exit!();
889    Ok(())
890  }
891
892  /// Declare a variable.
893  #[named]
894  #[inline]
895  pub fn declare_variable(&mut self) -> Result<(), Error> {
896    trace_enter!();
897    if self.compiler.depth == 0 {
898      return Ok(());
899    }
900    let token = self.previous.unwrap();
901    if self.compiler.has_local(&token) {
902      self.did_encounter_error("Already variable with this name in this scope.");
903      return Err(Error::AttemptedToRedeclareVariable);
904    }
905    self.add_local(token)?;
906    trace_exit!();
907    Ok(())
908  }
909
910  /// Add a local variable.
911  #[named]
912  pub fn add_local(&mut self, token: Token<'source>) -> Result<(), Error> {
913    trace_enter!();
914    trace_var!(token);
915    self.compiler.locals.push(Local::new(token, -1));
916    trace_exit!();
917    Ok(())
918  }
919
920  /// Define a variable.
921  #[named]
922  #[inline]
923  pub fn define_variable(&mut self, index: u16) -> Result<(), Error> {
924    trace_enter!();
925    trace_var!(index);
926    if self.compiler.depth > 0 {
927      self.mark_initialized()?;
928      return Ok(());
929    }
930    self.emit_instruction(Instruction::DefineGlobal(index))?;
931    trace_exit!();
932    Ok(())
933  }
934
935  /// Mark the last global as initialized.
936  #[named]
937  pub fn mark_initialized(&mut self) -> Result<(), Error> {
938    trace_enter!();
939    if self.compiler.depth == 0 {
940      return Ok(());
941    }
942    let last_local = self.compiler.locals.last_mut().unwrap();
943    trace_var!(last_local);
944    last_local.depth = self.compiler.depth;
945    trace_exit!();
946    Ok(())
947  }
948
949  /// Get an identifier constant.
950  #[named]
951  #[inline]
952  pub fn get_identifier_constant(&mut self, token: Token) -> Result<u16, Error> {
953    trace_enter!();
954    trace_var!(token);
955    let reference = self.intern_token(&token)?;
956    trace_var!(reference);
957    let value = Value::String(reference);
958    trace_var!(value);
959    let result = self.make_constant(value)?;
960    trace_var!(result);
961    trace_exit!();
962    Ok(result)
963  }
964
965  /// Switch to a new compiler.
966  #[named]
967  pub fn push_compiler(&mut self, function_type: FunctionType) -> Result<(), Error> {
968    trace_enter!();
969    trace_var!(function_type);
970    let function_name = self.intern_token(&self.previous.unwrap())?;
971    trace_var!(function_name);
972    let new_compiler = Box::new(Compiler::new(function_name, function_type));
973    trace_var!(new_compiler);
974    let old_compiler = replace(&mut self.compiler, new_compiler);
975    self.compiler.enclosing = Some(old_compiler);
976    trace_exit!();
977    Ok(())
978  }
979
980  /// Pop the last compiler.
981  #[named]
982  pub fn pop_compiler(&mut self) -> Result<Function, Error> {
983    trace_enter!();
984    self.emit_return()?;
985    let result = match self.compiler.enclosing.take() {
986      Some(enclosing) => {
987        let compiler = replace(&mut self.compiler, enclosing);
988        compiler.function
989      },
990      None => {
991        return Err(Error::TriedToPopTopCompiler);
992      },
993    };
994    trace_var!(result);
995    trace_exit!();
996    Ok(result)
997  }
998
999  /// Create a constant.
1000  #[named]
1001  #[inline]
1002  pub fn make_constant(&mut self, value: Value) -> Result<u16, Error> {
1003    trace_enter!();
1004    trace_var!(value);
1005    self.compiler.function.chunk.constants.push(value)?;
1006    let result = (self.compiler.function.chunk.constants.constants.len() - 1) as u16;
1007    trace_var!(result);
1008    trace_exit!();
1009    Ok(result)
1010  }
1011
1012  /// Match current token.
1013  #[named]
1014  pub fn r#match(&mut self, token_type: TokenType) -> Result<bool, Error> {
1015    trace_enter!();
1016    trace_var!(token_type);
1017    if !self.check(token_type) {
1018      return Ok(false);
1019    }
1020    self.advance()?;
1021    let result = true;
1022    trace_var!(result);
1023    trace_exit!();
1024    Ok(result)
1025  }
1026
1027  /// Check type of current token.
1028  #[named]
1029  pub fn check(&mut self, token_type: TokenType) -> bool {
1030    trace_enter!();
1031    trace_var!(token_type);
1032    let result = self.current.is_some() && self.current.unwrap().r#type == token_type;
1033    trace_var!(result);
1034    trace_exit!();
1035    result
1036  }
1037
1038  /// Emit a constant.
1039  #[named]
1040  #[inline]
1041  pub fn emit_constant(&mut self, value: Value) -> Result<(), Error> {
1042    trace_enter!();
1043    trace_var!(value);
1044    let instruction = self.compiler.function.chunk.constants.push(value)?;
1045    self.emit_instruction(instruction)?;
1046    trace_exit!();
1047    Ok(())
1048  }
1049
1050  /// Emit an instruction.
1051  #[named]
1052  #[inline]
1053  pub fn emit_instruction(&mut self, instruction: Instruction) -> Result<(), Error> {
1054    trace_enter!();
1055    trace_var!(instruction);
1056    self
1057      .compiler
1058      .function
1059      .chunk
1060      .instructions
1061      .append(instruction, self.previous.unwrap().line_number);
1062    trace_exit!();
1063    Ok(())
1064  }
1065
1066  /// Conclude.
1067  #[named]
1068  pub fn emit_return(&mut self) -> Result<(), Error> {
1069    trace_enter!();
1070    match self.compiler.function_type {
1071      FunctionType::Initializer => self.emit_instruction(Instruction::GetLocal(0))?,
1072      _ => self.emit_instruction(Instruction::Nil)?,
1073    };
1074    self.emit_instruction(Instruction::Return)?;
1075    trace_exit!();
1076    Ok(())
1077  }
1078
1079  /// Handle when we named a variable.
1080  #[named]
1081  pub fn did_name_variable(&mut self, name: Token, can_assign: bool) -> Result<(), Error> {
1082    trace_enter!();
1083    trace_var!(name);
1084    let get_op;
1085    let set_op;
1086    if let Some(index) = self.resolve_local(name) {
1087      get_op = Instruction::GetLocal(index);
1088      set_op = Instruction::SetLocal(index);
1089    } else if let Some(index) = self.resolve_upvalue(name) {
1090      get_op = Instruction::GetUpvalue(index);
1091      set_op = Instruction::SetUpvalue(index);
1092    } else {
1093      let index = self.get_identifier_constant(name)?;
1094      get_op = Instruction::GetGlobal(index);
1095      set_op = Instruction::SetGlobal(index);
1096    }
1097    if can_assign && self.r#match(TokenType::Equal)? {
1098      self.parse_expression()?;
1099      self.emit_instruction(set_op)?;
1100    } else {
1101      self.emit_instruction(get_op)?;
1102    }
1103    trace_exit!();
1104    Ok(())
1105  }
1106
1107  /// Parse precedence.
1108  #[named]
1109  pub fn parse_precedence(&mut self, precedence: Precedence) -> Result<(), Error> {
1110    trace_enter!();
1111    trace_var!(precedence);
1112    self.advance()?;
1113    let previous_rule = self.get_previous_rule().unwrap();
1114    trace_var!(previous_rule);
1115    if previous_rule.prefix.is_none() {
1116      self.did_encounter_error("Expect expression.");
1117      return Err(Error::ExpectedExpression);
1118    }
1119    let prefix = previous_rule.prefix.unwrap();
1120    let can_assign = precedence <= Precedence::Assignment;
1121    prefix(self, can_assign)?;
1122    while self.is_lower_precedence(precedence) {
1123      self.advance()?;
1124      let previous_rule = self.get_previous_rule().unwrap();
1125      let infix = previous_rule.infix.unwrap();
1126      infix(self, can_assign)?;
1127    }
1128    if can_assign && self.r#match(TokenType::Equal)? {
1129      self.did_encounter_error("Invalid assignment target.");
1130      return Err(Error::InvalidAssignmentTarget);
1131    }
1132    trace_exit!();
1133    Ok(())
1134  }
1135
1136  /// Is this current operation lower precedence?
1137  #[named]
1138  pub fn is_lower_precedence(&self, precedence: Precedence) -> bool {
1139    trace_enter!();
1140    trace_var!(precedence);
1141    let current_precedence = self.get_current_rule().unwrap().precedence;
1142    trace_var!(current_precedence);
1143    let result = precedence <= current_precedence;
1144    trace_var!(result);
1145    trace_exit!();
1146    result
1147  }
1148
1149  /// Get the previous rule.
1150  #[named]
1151  pub fn get_previous_rule(&self) -> Option<Rule<'source>> {
1152    trace_enter!();
1153    let result = match self.previous {
1154      None => None,
1155      Some(token) => self.get_rule(&token.r#type),
1156    };
1157    trace_var!(result);
1158    trace_exit!();
1159    result
1160  }
1161
1162  /// Get the current rule.
1163  #[named]
1164  pub fn get_current_rule(&self) -> Option<Rule<'source>> {
1165    trace_enter!();
1166    let result = match self.current {
1167      None => None,
1168      Some(token) => self.get_rule(&token.r#type),
1169    };
1170    trace_var!(result);
1171    trace_exit!();
1172    result
1173  }
1174
1175  /// Get a rule.
1176  #[named]
1177  pub fn get_rule(&self, token_type: &TokenType) -> Option<Rule<'source>> {
1178    trace_enter!();
1179    trace_var!(token_type);
1180    let result = self.rules.rules.get(token_type).cloned();
1181    trace_var!(result);
1182    trace_exit!();
1183    result
1184  }
1185
1186  /// Resolve a local reference.
1187  #[named]
1188  pub fn resolve_local(&mut self, token: Token) -> Option<u16> {
1189    trace_enter!();
1190    trace_var!(token);
1191    let result = self.compiler.resolve_local(token, &mut self.resolver_errors);
1192    while let Some(error) = self.resolver_errors.pop() {
1193      self.did_encounter_error(error);
1194    }
1195    result
1196  }
1197
1198  /// Resolve an upvalue.
1199  #[named]
1200  pub fn resolve_upvalue(&mut self, token: Token) -> Option<u16> {
1201    trace_enter!();
1202    trace_var!(token);
1203    let result = self.compiler.resolve_upvalue(token, &mut self.resolver_errors);
1204    while let Some(error) = self.resolver_errors.pop() {
1205      self.did_encounter_error(error);
1206    }
1207    trace_var!(result);
1208    trace_exit!();
1209    result
1210  }
1211}
hornvale/scripting_language/parser/mod.rs

hornvale/scripting_language/parser/
mod.rs
