microPython的源码解析之 parse.c

最新推荐文章于 2024-04-16 09:09:42 发布
最新推荐文章于 2024-04-16 09:09:42 发布
阅读量819 收藏 15
点赞数 23
分类专栏： micropython 文章标签： c语言 开发语言 micropython python 嵌入式硬件 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangzhechun/article/details/137767427
版权
本文深入解析MicroPython的parse.c源码，帮助读者理解MicroPython核心逻辑，特别是解析器的工作原理，涉及内存管理、常量折叠等关键功能。通过一系列文章，逐步剖析MicroPython的实现，适合嵌入式硬件和Python开发者学习。
摘要由CSDN通过智能技术生成

MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。
下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.

microPython Python最小内核源码解析
NI-motion运动控制c语言示例代码解析
python编程示例系列 python编程示例系列二
python的Web神器Streamlit

#include <stdbool.h> // 包含布尔类型定义
#include <stdint.h> // 包含整数类型定义
#include <stdio.h> // 包含标准输入输出定义
#include <unistd.h> // 包含 ssize_t 类型定义，用于跨平台的文件描述符操作
#include <assert.h> // 包含断言宏
#include <string.h> // 包含字符串操作函数

// 包含 MicroPython 相关的头文件
#include "py/lexer.h"
#include "py/parse.h"
#include "py/parsenum.h"
#include "py/runtime.h"
#include "py/objint.h"
#include "py/objstr.h"
#include "py/builtin.h"

// 预处理器指令，用于条件编译
#if MICROPY_ENABLE_COMPILER

// 定义规则动作的掩码，用于解析器内部表示规则的行为
#define RULE_ACT_ARG_MASK       (0x0f)
#define RULE_ACT_KIND_MASK      (0x30)
#define RULE_ACT_ALLOW_IDENT    (0x40)
#define RULE_ACT_ADD_BLANK      (0x80)
#define RULE_ACT_OR             (0x10)
#define RULE_ACT_AND            (0x20)
#define RULE_ACT_LIST           (0x30)

// 定义规则参数的掩码，用于解析器内部表示规则的参数
#define RULE_ARG_KIND_MASK      (0xf000)
#define RULE_ARG_ARG_MASK       (0x0fff)
#define RULE_ARG_TOK            (0x1000)
#define RULE_ARG_RULE           (0x2000)
#define RULE_ARG_OPT_RULE       (0x3000)

// 关闭格式化，避免代码在复制过程中被编辑器格式化
// *FORMAT-OFF*

// 枚举所有规则，包括有编译函数的规则和无编译函数的规则
enum {
   
// 定义有编译函数的规则
#define DEF_RULE(rule, comp, kind, ...) RULE_##rule,
#define DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC

    // 特殊节点，用于表示一个常量，通用的 Python 对象
    RULE_const_object,

// 定义无编译函数的规则
#define DEF_RULE(rule, comp, kind, ...)
#define DEF_RULE_NC(rule, kind, ...) RULE_##rule,
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
};

// 定义一个数组，对应每个规则的动作
static const uint8_t rule_act_table[] = {
   
#define or(n)                   (RULE_ACT_OR | n)
#define and(n)                  (RULE_ACT_AND | n)
#define and_ident(n)            (RULE_ACT_AND | n | RULE_ACT_ALLOW_IDENT)
#define and_blank(n)            (RULE_ACT_AND | n | RULE_ACT_ADD_BLANK)
#define one_or_more             (RULE_ACT_LIST | 2)
#define list                    (RULE_ACT_LIST | 1)
#define list_with_end           (RULE_ACT_LIST | 3)

#define DEF_RULE(rule, comp, kind, ...) kind,
#define DEF_RULE_NC(rule, kind, ...) kind,
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC

    0, // RULE_const_object

#define DEF_RULE(rule, comp, kind, ...)
#define DEF_RULE_NC(rule, kind, ...) kind,
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC

#undef or
#undef and
#undef and_ident
#undef and_blank
#undef one_or_more
#undef list
#undef list_with_end
};

// 定义规则参数数据的数组，合并存储
static const uint16_t rule_arg_combined_table[] = {
   
#define tok(t)                  (RULE_ARG_TOK | MP_TOKEN_##t)
#define rule(r)                 (RULE_ARG_RULE | RULE_##r)
#define opt_rule(r)             (RULE_ARG_OPT_RULE | RULE_##r)

#define DEF_RULE(rule, comp, kind, ...) __VA_ARGS__,
#define DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC

#define DEF_RULE(rule, comp, kind, ...)
#define DEF_RULE_NC(rule, kind, ...)  __VA_ARGS__,
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC

#undef tok
#undef rule
#undef opt_rule
};

// 定义宏，用于创建 N 个标识符的列表，N 是宏的参数数量
#define RULE_EXPAND(x) x
#define RULE_PADDING(rule, ...) RULE_PADDING2(rule, __VA_ARGS__, RULE_PADDING_IDS(rule))
#define RULE_PADDING2(rule, ...) RULE_EXPAND(RULE_PADDING3(rule, __VA_ARGS__))
#define RULE_PADDING3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) __VA_ARGS__
#define RULE_PADDING_IDS(r) PAD13_##r, PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r,

// 使用枚举创建规则参数在 rule_arg_combined_table 中占用空间的常量
enum {
   
#define DEF_RULE(rule, comp, kind, ...) RULE_PADDING(rule, __VA_ARGS__)
#define DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
#define_DEF_RULE(rule, comp, kind, ...)
#define_DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
};

// 定义宏，用于计算规则参数在 rule_arg_combined_table 中的起始位置
#define RULE_ARG_OFFSET(rule, ...) RULE_ARG_OFFSET2(rule, __VA_ARGS__, RULE_ARG_OFFSET_IDS(rule))
#define RULE_ARG_OFFSET2(rule, ...) RULE_EXPAND(RULE_ARG_OFFSET3(rule, __VA_ARGS__))
#define RULE_ARG_OFFSET3(rule, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) _14
#define RULE_ARG_OFFSET_IDS(r) PAD13_##r, PAD12_##r, PAD11_##r, PAD10_##r, PAD9_##r, PAD8_##r, PAD7_##r, PAD6_##r, PAD5_##r, PAD4_##r, PAD3_##r, PAD2_##r, PAD1_##r, PAD0_##r,

// 使用上述枚举值创建每个规则参数数据的偏移表，索引 rule_arg_combined_table
// 偏移量需要 9 位存储，但这里只存储低 8 位。第 9 位在 get_rule_arg 函数中计算
static const uint8_t rule_arg_offset_table[] = {
   
#define DEF_RULE(rule, comp, kind, ...) RULE_ARG_OFFSET(rule, __VA_ARGS__) & 0xff,
#define DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
    0, // RULE_const_object
#define DEF_RULE(rule, comp, kind, ...)
#define DEF_RULE_NC(rule, kind, ...) RULE_ARG_OFFSET(rule, __VA_ARGS__) & 0xff,
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
};

// 定义一个常量，用于确定 rule_arg_offset_table 中值的第 9 位
static const size_t FIRST_RULE_WITH_OFFSET_ABOVE_255 =
#define DEF_RULE(rule, comp, kind, ...) RULE_ARG_OFFSET(rule, __VA_ARGS__) >= 0x100 ? RULE_##rule :
#define DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
#define_DEF_RULE(rule, comp, kind, ...)
#define_DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
0;

#if MICROPY_DEBUG_PARSE_RULE_NAME
// 定义一个数组，对应每个规则的名称
static const char *const rule_name_table[] = {
   
#define DEF_RULE(rule, comp, kind, ...) #rule,
#define DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
    "", // RULE_const_object
#define_DEF_RULE(rule, comp, kind, ...)
#define_DEF_RULE_NC(rule, kind, ...)
#include "py/grammar.h"
#undef DEF_RULE
#undef DEF_RULE_NC
};
#endif

// 定义解析器栈的结构体
typedef struct _rule_stack_t {
   
    size_t src_line : (8 * sizeof(size_t) - 8); // 源代码行号，使用位字段存储
    size_t rule_id : 8; // 规则标识符，使用位字段存储
    size_t arg_i; // 参数索引，指示 "列表" 中的元素数量
} rule_stack_t;

// 定义解析器块的结构体
typedef struct _mp_parse_chunk_t {
   
   size_t alloc;
    union {
   
        size_t used;
        struct _mp_parse_chunk_t *next;
    } union_;
    byte data[];
} mp_parse_chunk_t;

// 定义解析器的结构体
typedef struct _parser_t {
   
    size_t rule_stack_alloc;
    size_t rule_stack_top;
    rule_stack_t *rule_stack;

    size_t result_stack_alloc;
    size_t result_stack_top;
    mp_parse_node_t *result_stack;

    mp_lexer_t *lexer;

    mp_parse_tree_t tree;
    mp_parse_chunk_t *cur_chunk;

    #if MICROPY_COMP_CONST
    mp_map_t consts;
    #endif
} parser_t;

// 定义函数原型
static void push_result_rule(parser_t *parser, size_t src_line, uint8_t rule_id, size_t num_args);

// 定义获取规则参数的函数
static const uint16_t *get_rule_arg(uint8_t r_id) {
   
    size_t off = rule_arg_offset_table[r_id];
    if (r_id >= FIRST_RULE_WITH_OFFSET_ABOVE_255) {
   
        off |= 0x100;
    }
    return &rule_arg_combined_table[off];
}

// 定义解析器的内存分配函数
static void *parser_alloc(parser_t *parser, size_t num_bytes) {
   
    // 使用自定义的内存分配器，将解析节点顺序存储在大块内存中

    mp_parse_chunk_t *chunk = parser->cur_chunk;

    if (chunk != NULL && chunk->union_.used + num_bytes > chunk->alloc) {
   
        // 如果当前块没有足够的空间，则尝试扩展
        mp_parse_chunk_t *new_data = (mp_parse_chunk_t *)m_renew_maybe(byte, chunk,
            sizeof(mp_parse_chunk_t) + chunk->alloc,
            sizeof(mp_parse_chunk_t) + chunk->alloc + num_bytes, false);
        if (new_data == NULL) {
   
            // 无法扩展现有内存；将其缩小以适应之前的使用情况
            (void)m_renew_maybe(byte, chunk, sizeof(mp_parse_chunk_t) + chunk->alloc,
                sizeof(mp_parse_chunk_t) + chunk->union_.used, false);
            chunk->alloc = chunk->union_.used;
            chunk->union_.next = parser->tree.chunk;
            parser->tree.chunk = chunk;
            chunk = NULL;
        } else {
   
            // 扩展现有内存成功
            chunk->alloc += num_bytes;
        }
    }

    if (chunk == NULL) {
   
        // 没有之前的块，分配一个新块
        size_t alloc = MICROPY_ALLOC_PARSE_CHUNK_INIT;
        if (alloc < num_bytes) {
   
            alloc = num_bytes;
        }
        chunk = (mp_parse_chunk_t *)m_new(byte,
最低0.47元/天 解锁文章
openwin_top
关注
专栏目录
microPython的源码解析之 lexer.c
zhangzhechun的专栏
04-02 1669
MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。
MicroPython 源码解析 在 Windows 环境
diaokuang5304的博客
09-02 701
mark 转载于:https://www.cnblogs.com/juwan/p/11448064.html
micropython源码分析之c模组注册
qq_34440409的博客
06-07 825
micropython源码分析之c模组注册
micropython源码分析之qstr
qq_34440409的博客
05-12 2075
前言 最近在研究micropython的源码编译过程，简单记录下关于qstr部分内容。 标识符与相应对象的联系 Micropython中有很多标识符，例如lcd.py中出现的标识符有：import、lcd、init、print、“hello”。这些标识符最终都需要与某个对象或操作联系起来。那么这种联系是如何建立的呢？那就是通过QSTR。 QSTR是uniQue STRing的简称，是一种字符串内存驻留方法。我们知道同一个标识符可能在源代码中出现多次，如果我们在每个出现的地方都要保留一份这个标识符的拷贝，就会
MicroPython使用总结——STM32F4移植、源码探析、C模块扩展 （PDF格式在作者个人中心文件下载）
qq_37663504的博客
04-15 598
目录信息
MicroPython 解析器
u012441962的博客
11-20 1127
MicroPython的解析器实现是在pyexec.c中实现的，核心函数是 STATIC int parse_compile_execute(const void *source, mp_parse_input_kind_t input_kind, int exec_flags) 参数解析： source ： 命令行或者文件名 input_kind：输入类型 exec_flags：执行方式 典型...
microPython的源码解析之 persistentcode.c
zhangzhechun的专栏
04-15 744
下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.这些函数处理了字节码和本地代码的加载和保存，以及相关的元数据和常量表。代码中的注释提供了对每个函数和操作的详细解释，有助于理解代码的功能和实现方式。这个流程图展示了从读取或保存文件头开始，到处理qstr、对象和原始代码，再到处理子代码（如果有）的整个过程。: 将编译模块保存到文件。
microPython的源码解析之 builtinimport.c
zhangzhechun的专栏
03-30 1081
它包含了处理相对导入、查找和加载模块的逻辑，以及对内置模块和文件系统模块的支持。代码中的注释详细解释了每个函数和代码块的作用，有助于理解 MicroPython 是如何处理模块导入的。程序的功能是实现 MicroPython 中的模块导入机制。它支持从内置模块、文件系统模块以及冻结模块中导入所需的模块。：程序解析传入的导入请求，包括模块名称、导入级别（对于相对导入）以及是否需要从元组中导入特定的属性。：加载的模块会被注册到一个字典中，以便将来的导入请求可以重用已加载的模块。对于文件，程序将执行模块的代码。
microPython的源码解析之 runtime.c
最新发布
zhangzhechun的专栏
04-16 509
MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。 下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.
micropython-1.3.6 源代码
11-12
MicroPython - a lean and efficient Python implementation for microcontrollers and constrained systems
microPython的源码解析之 nativeglue.c
zhangzhechun的专栏
04-04 1063
代码主要涉及本地桥接（将MicroPython对象和C/C++代码相互转换）和函数表的定义，这些函数表用于MicroPython的本地代码生成和执行。下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.根据传入的类型，执行不同的转换逻辑，包括对象、布尔值、整数、无符号整数和指针类型。这个函数在没有定义集合类型时抛出不支持的异常。
micropython运行机制_在 MicroPython 中调用 ujson 内置模块的功能的实例，讲点 MicroPython C 层面的解释执行、异常捕获、内存回收、内置对象等内容。...
weixin_39786850的博客
01-27 726
oh！！！想起来了，刚好可以写一篇关于深度使用 micropython 的文章！会有一些额外的知识讲解哒。起因这次的起因是需要一个 C 与 Python 层面共用的配置模块，就是想在 micropython 中准备一个配置项的功能，刚好也讨论到了不妨直接使用 ujson 的模块功能。(ujson 就是 json)，然后这个模块的 Python 代码通常是这样的。#!/usr/bin/python3...
在MicroPython源码中找到对应的API
qq_44810226的博客
07-29 369
在MicroPython脚本中使用import XXX，其实是引入了一个对象，这个对象有很多个方法使用。 如果没有文档的话我们怎么才能找到对应的接口有哪些？怎么用。 比如说我在脚本中import了math库用于数学计算。然后使用了degree这个方法。接下来我们去源码中找到对应的实现函数。 观察一下MacroPython中添加一个库文件以及一个函数的方法： 下面是math库的所有函数以及变量声明，所以通过搜索MP_ROM_QSTR(MP_QSTR_XXX函数名，就可以找...
MicroPython中Python与C代码是如何交互的
HaaS技术社区的博客
10-27 1665
1、Python代码和C代码字符关联 本节就来介绍下模块扩展过程中Python字符是怎么和C字符(例如：模块名，类名，变量名，函数名等)关联起来的？以ADC 类名字符来举例说明下关联过程的： C代码字符ADC STATIC const mp_rom_map_elem_t driver_locals_dict_table[] = { {MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_R..
一、MicroPython移植到任意平台（简介以及源码裁剪）
BIN-XYB的博客
07-19 2497
MicroPython简介以及源码移植裁剪
【雕爷学编程】MicroPython手册之内置函数
雕爷学编程
09-08 660
请注意，MicroPython 的内置函数与标准 Python 中的内置函数可能存在一些差异和限制，具体的行为和功能可以参考 MicroPython 的官方文档或相关资料。3、兼容性好：MicroPython的内置函数与标准的Python 3基本保持一致，这意味着你可以在不同的平台和设备上运行相同的代码，而不需要做太多的修改。2、功能强大：MicroPython的内置函数可以用来执行各种常见的操作，例如打印输出，计算长度，判断类型，生成序列，获取输入等。你可以对数据进行切片，拼接，排序，查找，替换等操作。
microPython的源码解析之 objexcept.c
zhangzhechun的专栏
04-08 752
MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。 下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.
Micropython解释器大致执行流程
Helping BIOSer become Awesome!
06-21 4666
最终由mp_execute_bytecode执行bytecode  // execute the byte code with the correct globals context code_state->old_globals = mp_globals_get(); mp_globals_set(self->globals); mp_vm_return_kin
PHPWind 4.3.2060428 源码解析：global.php与核心机制
"PHPWind 源码解析" PHPWind 是一款流行的开源社区论坛软件，它的源码解析文档主要关注了 `global.php` 文件及其相关的源码。这份文档是由用户 claudedb 在霏凡论坛原创分享的，目的是帮助读者理解 PHPWind 4.3....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

openwin_top

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值