7.6 QuickJS核心代码流程 js_create_function创建函数对象以及包含的子函数

最新推荐文章于 2023-09-07 15:21:39 发布
最新推荐文章于 2023-09-07 15:21:39 发布
阅读量528 收藏 5
点赞数
文章标签： javascript 开发语言 ecmascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kking_edc/article/details/124658304
版权

js_create_function 函数会从 JSFunctionDef (2.2)中创建一个函数对象和子函数，然后释放 JSFunctionDef。函数体如下：

/* create a function object from a function definition. The function
   definition is freed. All the child functions are also created. It
   must be done this way to resolve all the variables. */
static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
{
    JSValue func_obj;
    JSFunctionBytecode *b;
    struct list_head *el, *el1;
    int stack_size, scope, idx;
    int function_size, byte_code_offset, cpool_offset;
    int closure_var_offset, vardefs_offset;

    //解析1
    for (scope = 0; scope < fd->scope_count; scope++) {
        fd->scopes[scope].first = -1;
    }
    if (fd->has_parameter_expressions) {
        /* special end of variable list marker for the argument scope */
        fd->scopes[ARG_SCOPE_INDEX].first = ARG_SCOPE_END;
    }
    for (idx = 0; idx < fd->var_count; idx++) {
        JSVarDef *vd = &fd->vars[idx];
        vd->scope_next = fd->scopes[vd->scope_level].first;
        fd->scopes[vd->scope_level].first = idx;
    }
    for (scope = 2; scope < fd->scope_count; scope++) {
        JSVarScope *sd = &fd->scopes[scope];
        if (sd->first < 0)
            sd->first = fd->scopes[sd->parent].first;
    }
    for (idx = 0; idx < fd->var_count; idx++) {
        JSVarDef *vd = &fd->vars[idx];
        if (vd->scope_next < 0 && vd->scope_level > 1) {
            scope = fd->scopes[vd->scope_level].parent;
            vd->scope_next = fd->scopes[scope].first;
        }
    }

    /* if the function contains an eval call, the closure variables
       are used to compile the eval and they must be ordered by scope,
       so it is necessary to create the closure variables before any
       other variable lookup is done. */
    if (fd->has_eval_call)
        add_eval_variables(ctx, fd);

    /* add the module global variables in the closure */
    if (fd->module) {
        if (add_module_variables(ctx, fd))
            goto fail;
    }

    /* first create all the child functions */
    list_for_each_safe(el, el1, &fd->child_list) {
        JSFunctionDef *fd1;
        int cpool_idx;

        fd1 = list_entry(el, JSFunctionDef, link);
        cpool_idx = fd1->parent_cpool_idx;
        func_obj = js_create_function(ctx, fd1);
        if (JS_IsException(func_obj))
            goto fail;
        /* save it in the constant pool */
        assert(cpool_idx >= 0);
        fd->cpool[cpool_idx] = func_obj;
    }

#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 4)
    if (!(fd->js_mode & JS_MODE_STRIP)) {
        printf("pass 1\n");
        dump_byte_code(ctx, 1, fd->byte_code.buf, fd->byte_code.size,
                       fd->args, fd->arg_count, fd->vars, fd->var_count,
                       fd->closure_var, fd->closure_var_count,
                       fd->cpool, fd->cpool_count, fd->source, fd->line_num,
                       fd->label_slots, NULL);
        printf("\n");
    }
#endif

    if (resolve_variables(ctx, fd))
        goto fail;

#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 2)
    if (!(fd->js_mode & JS_MODE_STRIP)) {
        printf("pass 2\n");
        dump_byte_code(ctx, 2, fd->byte_code.buf, fd->byte_code.size,
                       fd->args, fd->arg_count, fd->vars, fd->var_count,
                       fd->closure_var, fd->closure_var_count,
                       fd->cpool, fd->cpool_count, fd->source, fd->line_num,
                       fd->label_slots, NULL);
        printf("\n");
    }
#endif

    if (resolve_labels(ctx, fd))
        goto fail;

    if (compute_stack_size(ctx, fd, &stack_size) < 0)
        goto fail;

    if (fd->js_mode & JS_MODE_STRIP) {
        function_size = offsetof(JSFunctionBytecode, debug);
    } else {
        function_size = sizeof(*b);
    }
    cpool_offset = function_size;
    function_size += fd->cpool_count * sizeof(*fd->cpool);
    vardefs_offset = function_size;
    if (!(fd->js_mode & JS_MODE_STRIP) || fd->has_eval_call) {
        function_size += (fd->arg_count + fd->var_count) * sizeof(*b->vardefs);
    }
    closure_var_offset = function_size;
    function_size += fd->closure_var_count * sizeof(*fd->closure_var);
    byte_code_offset = function_size;
    function_size += fd->byte_code.size;

    b = js_mallocz(ctx, function_size);
    if (!b)
        goto fail;
    b->header.ref_count = 1;

    b->byte_code_buf = (void *)((uint8_t*)b + byte_code_offset);
    b->byte_code_len = fd->byte_code.size;
    memcpy(b->byte_code_buf, fd->byte_code.buf, fd->byte_code.size);
    js_free(ctx, fd->byte_code.buf);
    fd->byte_code.buf = NULL;

    b->func_name = fd->func_name;
    if (fd->arg_count + fd->var_count > 0) {
        if ((fd->js_mode & JS_MODE_STRIP) && !fd->has_eval_call) {
            /* Strip variable definitions not needed at runtime */
            int i;
            for(i = 0; i < fd->var_count; i++) {
                JS_FreeAtom(ctx, fd->vars[i].var_name);
            }
            for(i = 0; i < fd->arg_count; i++) {
                JS_FreeAtom(ctx, fd->args[i].var_name);
            }
            for(i = 0; i < fd->closure_var_count; i++) {
                JS_FreeAtom(ctx, fd->closure_var[i].var_name);
                fd->closure_var[i].var_name = JS_ATOM_NULL;
            }
        } else {
            b->vardefs = (void *)((uint8_t*)b + vardefs_offset);
            memcpy(b->vardefs, fd->args, fd->arg_count * sizeof(fd->args[0]));
            memcpy(b->vardefs + fd->arg_count, fd->vars, fd->var_count * sizeof(fd->vars[0]));
        }
        b->var_count = fd->var_count;
        b->arg_count = fd->arg_count;
        b->defined_arg_count = fd->defined_arg_count;
        js_free(ctx, fd->args);
        js_free(ctx, fd->vars);
    }
    b->cpool_count = fd->cpool_count;
    if (b->cpool_count) {
        b->cpool = (void *)((uint8_t*)b + cpool_offset);
        memcpy(b->cpool, fd->cpool, b->cpool_count * sizeof(*b->cpool));
    }
    js_free(ctx, fd->cpool);
    fd->cpool = NULL;

    b->stack_size = stack_size;

    if (fd->js_mode & JS_MODE_STRIP) {
        JS_FreeAtom(ctx, fd->filename);
        dbuf_free(&fd->pc2line);    // probably useless
    } else {
        /* XXX: source and pc2line info should be packed at the end of the
           JSFunctionBytecode structure, avoiding allocation overhead
         */
        b->has_debug = 1;
        b->debug.filename = fd->filename;
        b->debug.line_num = fd->line_num;

        //DynBuf pc2line;
        //compute_pc2line_info(fd, &pc2line);
        //js_free(ctx, fd->line_number_slots)
        b->debug.pc2line_buf = js_realloc(ctx, fd->pc2line.buf, fd->pc2line.size);
        if (!b->debug.pc2line_buf)
            b->debug.pc2line_buf = fd->pc2line.buf;
        b->debug.pc2line_len = fd->pc2line.size;
        b->debug.source = fd->source;
        b->debug.source_len = fd->source_len;
    }
    if (fd->scopes != fd->def_scope_array)
        js_free(ctx, fd->scopes);

    b->closure_var_count = fd->closure_var_count;
    if (b->closure_var_count) {
        b->closure_var = (void *)((uint8_t*)b + closure_var_offset);
        memcpy(b->closure_var, fd->closure_var, b->closure_var_count * sizeof(*b->closure_var));
    }
    js_free(ctx, fd->closure_var);
    fd->closure_var = NULL;

    b->has_prototype = fd->has_prototype;
    b->has_simple_parameter_list = fd->has_simple_parameter_list;
    b->js_mode = fd->js_mode;
    b->is_derived_class_constructor = fd->is_derived_class_constructor;
    b->func_kind = fd->func_kind;
    b->need_home_object = (fd->home_object_var_idx >= 0 ||
                           fd->need_home_object);
    b->new_target_allowed = fd->new_target_allowed;
    b->super_call_allowed = fd->super_call_allowed;
    b->super_allowed = fd->super_allowed;
    b->arguments_allowed = fd->arguments_allowed;
    b->backtrace_barrier = fd->backtrace_barrier;
    b->realm = JS_DupContext(ctx);

    add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
    
#if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 1)
    if (!(fd->js_mode & JS_MODE_STRIP)) {
        js_dump_function_bytecode(ctx, b);
    }
#endif

    if (fd->parent) {
        /* remove from parent list */
        list_del(&fd->link);
    }

    js_free(ctx, fd);
    return JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
 fail:
    js_free_function_def(ctx, fd);
    return JS_EXCEPTION;
}
pass 1

js_create_function 函数还会使用 add_module_variables 函数添加模块闭包中的全局变量。import 其他模块的全局会通过 js_parse_import 函数作为闭包变量添加进来，add_module_variables 函数是添加 module 里的全局变量，将模块的全局变量通过 add_closure_var 函数加到当前函数定义里，并处理类型是 JS_EXPORT_TYPE_LOCAL 的 exports 的变量。add_module_variables 函数会先添加通过 js_parse_import 函数导入作为闭包变量的全局变量，添加闭包变量调用的是 add_closure_var 函数。遍历 fd->child_list 递归使用 js_create_function 函数创建所有子函数，将创建的子函数对象保存在 fd->cpool 里，cpool 是一个 JSValue 结构体，JSValue 是最基本的单位，这个结构体会有一个 tag 来标示 JSValue 的类型，值是保存在 JSValueUnion 里，值可以是整型和浮点，也可以是一个对象的指针，指针指向的对象是由引用计数来进行管理的，引用计数结构体是 JSRefCountHeader。这里 JSValue 的值是个数组。

2 解析

解析1

函数最开始重新计算作用域的关联，通过四步将作用域和变量关联起来，方便在作用域和父作用域中查找变量。

  • 遍历JSFunctionDef中的作用域，设置链表头
  • 遍历变量列表，将变量对应作用域

第二步遍历变量列表，将变量对应作用域层级链表头放到变量的 scope_next 里，并将变量所在列表索引放到变量对应作用域层级链表头里。第三步再遍历作用域，将没有变量的作用域指向父作用域的链表。第四步将当前作用域和父作用域变量链表连起来。通过 fd->has_eval_call 来看是否有调用 eval，如果有，通过 add_eval_variables 来添加 eval 变量。如果函数里有 eval 调用，add_eval_variables 函数会将 eval 里的闭合变量按照作用域排序。add_eval_variables 函数会为 eval 定义一个给参数作用域用的额外的变量对象，还有需定义可能会使用的 arguments，还在参数作用域加个 arguments binding，另外，eval 可以使用 enclosing 函数的所有变量，因此需要都加到闭包里。

你回到了你的家
关注
JavaScript 创建函数的 4 种方法
我的博客，不一样的自我表达
06-15 273
Concised Arrow Function Expression, 是一个函数，您可以直接返回而无需编写 return 语句。这样做的好处是即使函数是在代码的最底部声明的，您也可以使用该函数。Function Expression是一个函数，如果您在变量中分配一个函数。Arrow Function Expression，这个函数就像一个函数表达式，但function我们使用箭头=>代替书写。关注我的博客，您将在其中获得提示、技巧和挑战，以保持您的技能敏锐。
金蝶云星空标准版V7.6_产品培训_基础_系统管理.pptx
12-23
金蝶云星空标准版V7.6是一款针对中小企业的财务管理软件，其系统管理部分主要涉及角色管理、权限管理和用户管理等方面。以下是对这些关键概念的详细解释： **角色管理**： 角色是系统中预定义的一组权限集合，分为...
7.4 QuickJS核心代码流程 创建顶级函数定义
kking_edc的博客
05-09 574
1 函数调用链 js_new_function_def 会通过运行 JS_NewAtom 函数，来返回一个文件名 JSAtom。JSAtom是一个别名，定义如下： typedef uint32_t JSAtom; 其取值范围如下： enum { JS_ATOM_TYPE_STRING = 1, JS_ATOM_TYPE_GLOBAL_SYMBOL, JS_ATOM_TYPE_SYMBOL, JS_ATOM_TYPE_PRIVATE, }; JS_NewRuntime 函数
javascript Object.create()函数
NO CODE NO LIFE
08-19 551
Object.create()
JS中的函数-内部函数，子调用函数和返回值为函数的函数
Qbit编程学习笔记
12-24 9007
自调用函数(Self-invoking Functions) 自调用函数也是匿名函数的一种表现形式，这个函数在定义之后，直接调用。如下 (  function(){      alert('haha');   }   )()  看起来还挺怪异，不过确实很简单。  自调用函数很方便使用，可以不用定义更多的全局变量。还有个好处，就是这个函数不能被执行两遍。真是非常适合做初始
javascript中的function函数的创建方法
CShouziwangDN的博客
09-25 1159
在javascript中创建function函数的方法 有两种 我们先来看看 第一种方法： //格式 function 函数名称（）{} 结尾无需加；号。 function func(){ //这里写各种 JS语句！ } func();//函数的调用 直接 函数名称（）； 下面 是第二种 定制function函数的方法！ //格式 var变量名=function(){}; 且结尾需要添加分号。 var func1=function(){ //这里写各种JS的语句 }; func1();//函数的调用
nuttx-7.6.rar_Nuttx_dwt_nuttx 延时函数_nuttx驱动模型_realtime
09-21
这个压缩包“nuttx-7.6.rar”包含了与Nuttx操作系统相关的源代码、文档和示例，帮助开发者理解和使用Nuttx系统。 首先，我们来看看Nuttx的延时函数。在实时操作系统中，延时函数是非常关键的，因为它允许任务在指定...
speak_freely-7.6a.zip_rtp_rtp voip_speak fs 7.6a_speak-freely_vo
09-19
《深入理解VOIP技术：基于speak_freely-7.6a的应用与分析》 VOIP（Voice over Internet Protocol）技术，即通过互联网传输语音，是现代通信领域的重要组成部分。speak_freely作为一款优秀的VOIP软件，因其支持高...
EOS_Platform_7.6_Enterprise_Edition_Linux
04-15
JRE包含了运行Java应用所需的所有组件，包括Java虚拟机、类库以及必要的工具。这意味着EOS Platform 7.6可能基于Java开发，因此需要先安装JRE才能运行。 在Linux运维场景下，理解和掌握这些文件的作用至关重要。...
quickjs-modules:QuickJS的某些模块（mmap，检查）
03-09
quickjs-模块 QuickJS的一些模块 深的 find（object，（obj，key）=> {}） get（对象，指针） 设置（对象，指针，值） 未设置（对象，指针） 检查 检查（值[，选项]） 贴图 mmap（addr，size，prot，flags，fd，offset） munmap（地址） 小路 基本名 坍塌 目录名 存在 姓氏 匹配 getcwd 回家 Getsep isAbsolute isRelative isDirectory isSymlink isSeparator 长度 成分 阅读链接 真实路径 正确的 跳过 skipSeparator 绝对 附加 典范 康卡特 找 归一化 相对的 加入 解析 格式 解决 定界符 九月 指针 新指针（[数组|字符串|指针]） 树行者 新的TreeWalker（root [，flags]） 新的Tree
js 获取子节点函数 (兼容FF与IE)
12-12
代码如下:function getFirstChild(obj) { var result = obj.firstChild; while (!result.tagName) { result = result.nextSibling; } return result; } function getNextChild(obj) { var result = obj.nextSibling; while (!result.tagName) { result = result.nextSibling; } return result; }
javascript 的 create
weixin_30470643的博客
06-23 233
create create([superclass][, methods...]) -> Class创建一个类。 Class.create 返回一个函数，当该函数被调用时，会自动调用它自己的 initialize 方法。 从 1.6 版开始，Class.create 接受两种类型的参数。如果第一个参数是 Class，则该类作为新类的基类， 新类将会继承基类中所有的方法。否...
JS对象创建 Object.create() 方法
热门推荐
技术熊的博客小窝
06-07 1万+
概述 Object.create() 方法创建一个拥有指定原型和若干个指定属性的对象。 语法 Object.create(proto, [ propertiesObject ]) 通过Object.create 方法可以创建对象，在这里有两个参数，第一个参数是对象，第二个参数是该对象的属性设置 我们可以这样去创建对象 var obj = Obje...
Object.create()实现原型式继承
个人前端记录
05-16 2809
我们可以从最初的混合继承模式，慢慢说起Object.create()的前因后果。 一般来说，使用构造函数结合原型的混合模式，可以为特定的实例共享属性和方法。 比较常见的是下面的形式，也是最基本的使用： function Person(name){ this.name = name; }; Person.prototype.sayName = function(){ aler...
JS:子构造函数借用父构造函数继承属性和方法
weixin_46682277的博客
06-18 418
ES6之前，因为没有extends继承，所以要想使用父构造函数中的属性，需要借用父构造函数继承属性。 // 父构造函数 function Father(uname,age){ this.uname = uname; this.age = age; } // 子构造函数 function Son(uname,age,sex){ // 这时子构造函数想要使用父构造函数中的属性，要用到call()方法，同时把this更改为子.
JS中的【函数】与【方法】——“父慈子孝”
最新发布
一个做过前端开发的产品经理，经历过睿智产品的折磨导致脱发之后，励志要翻身"农奴"把歌唱，一边打入敌人内部一边持续提升自己，为我们广大开发同胞谋福祉，坚决抵制睿智产品折磨我们码农兄弟！
09-07 162
用简洁易懂的语言，生动形象的例子，快速告诉你JS中的函数与方法到底有啥区别
JavaScript-函数
qq_41049094的博客
04-07 777
今天来复习js中函数的相关知识，主要包括函数的概念以及相关用法。 函数概念 函数（function），也叫做功能、方法，函数可以将一段代码封装起来，被封装的函数具备某一项特殊的功能，内部封装的一段代码作为一个完整的结构体，要执行就都执行，要不执行就都不执行 函数的作用就是封装一段代码，将来可以重复使用 函数声明 函数声明又叫函数定义，函数必须先定义再使用 如果没有定义函数直接引用，会报一个引用错误 函数声明语法：function 函数名(){封装的结构体;}; 特点：函数声明的时候，函数体并不会执行，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值