boa_engine 0.22.0

Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use super::RegisterOperand;
use crate::{
    Context, JsExpect, JsResult,
    builtins::array::Array,
    js_string,
    object::IntegrityLevel,
    property::PropertyDescriptor,
    vm::opcode::{Address, Operation},
};
use thin_vec::ThinVec;

/// `TemplateLookup` implements the Opcode Operation for `Opcode::TemplateLookup`
///
/// Operation:
///  - Lookup if a tagged template object is cached and skip the creation if it is.
#[derive(Debug, Clone, Copy)]
pub(crate) struct TemplateLookup;

impl TemplateLookup {
    #[inline(always)]
    pub(super) fn operation(
        (jump, site, dst): (Address, u64, RegisterOperand),
        context: &mut Context,
    ) {
        if let Some(template) = context.realm().lookup_template(site) {
            context.vm.set_register(dst.into(), template.into());
            context.vm.frame_mut().pc = u32::from(jump);
        }
    }
}

impl Operation for TemplateLookup {
    const NAME: &'static str = "TemplateLookup";
    const INSTRUCTION: &'static str = "INST - TemplateLookup";
    const COST: u8 = 3;
}

/// `TemplateCreate` implements the Opcode Operation for `Opcode::TemplateCreate`
///
/// Operation:
///  - Create a new tagged template object and cache it.
#[derive(Debug, Clone, Copy)]
pub(crate) struct TemplateCreate;

impl TemplateCreate {
    #[inline(always)]
    pub(super) fn operation(
        (site, dst, values): (u64, RegisterOperand, ThinVec<u32>),
        context: &mut Context,
    ) -> JsResult<()> {
        let count = values.len() / 2;
        let template =
            Array::array_create(count as u64, None, context).js_expect("cannot fail per spec")?;
        let raw_obj =
            Array::array_create(count as u64, None, context).js_expect("cannot fail per spec")?;

        let mut index = 0;
        let mut cooked = true;
        for value in values {
            if cooked {
                let cooked_value = context.vm.get_register(value as usize);
                template
                    .define_property_or_throw(
                        index,
                        PropertyDescriptor::builder()
                            .value(cooked_value.clone())
                            .writable(false)
                            .enumerable(true)
                            .configurable(false),
                        context,
                    )
                    .js_expect("should not fail on new array")?;
            } else {
                let raw_value = context.vm.get_register(value as usize);
                raw_obj
                    .define_property_or_throw(
                        index,
                        PropertyDescriptor::builder()
                            .value(raw_value.clone())
                            .writable(false)
                            .enumerable(true)
                            .configurable(false),
                        context,
                    )
                    .js_expect("should not fail on new array")?;
                index += 1;
            }

            cooked = !cooked;
        }

        raw_obj
            .set_integrity_level(IntegrityLevel::Frozen, context)
            .js_expect("should never fail per spec")?;
        template
            .define_property_or_throw(
                js_string!("raw"),
                PropertyDescriptor::builder()
                    .value(raw_obj)
                    .writable(false)
                    .enumerable(false)
                    .configurable(false),
                context,
            )
            .js_expect("should never fail per spec")?;
        template
            .set_integrity_level(IntegrityLevel::Frozen, context)
            .js_expect("should never fail per spec")?;

        context.realm().push_template(site, template.clone());

        context.vm.set_register(dst.into(), template.into());
        Ok(())
    }
}

impl Operation for TemplateCreate {
    const NAME: &'static str = "TemplateCreate";
    const INSTRUCTION: &'static str = "INST - TemplateCreate";
    const COST: u8 = 6;
}