microPython的源码解析之 binary.c

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

#include <stdint.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>

#include "py/binary.h"
#include "py/smallint.h"
#include "py/objint.h"
#include "py/runtime.h"

// 辅助函数，用于处理二进制编码的数据

#ifndef alignof
#define alignof(type) offsetof(struct {
      char c; type t; }, t)
#endif

size_t mp_binary_get_size(char struct_type, char val_type, size_t *palign) {
   
    size_t size = 0;
    int align = 1;
    switch (struct_type) {
   
        case '<':
        case '>':
            switch (val_type) {
   
                case 'b':
                case 'B':
                    size = 1;
                    break;
                case 'h':
                case 'H':
                    size = 2;
                    break;
                case 'i':
                case 'I':
                    size = 4;
                    break;
                case 'l':
                case 'L':
                    size = 4;
                    break;
                case 'q':
                case 'Q':
                    size = 8;
                    break;
                case 'P':
                case 'O':
                case 'S':
                    size = sizeof(void *);
                    break;
                case 'e':
                    size = 2;
                    break;
                case 'f':
                    size = 4;
                    break;
                case 'd':
                    size = 8;
                    break;
            }
            break;
        case '@': {
   
            // TODO:
            // 对齐的最简单启发式方法是按值大小对齐，但这并不适用于“比int类型大”的类型，
            // 例如，长整型可能有很好的对齐方式
            // 因此，我们引入了单独的对齐处理，但正式支持它与实际支持
            // 特定的（或任何）ABI是不同的。
            switch (val_type) {
   
                case BYTEARRAY_TYPECODE:
                case 'b':
                case 'B':
                    align = size = 1;
                    break;
                case 'h':
                case 'H':
                    align = alignof(short);
                    size = sizeof(short);
                    break;
                case 'i':
                case 'I':
                    align = alignof(int);
                    size = sizeof(int);
                    break;
                case 'l':
                case 'L':
                    align = alignof(long);
                    size = sizeof(long);
                    break;
                case 'q':
                case 'Q':
                    align = alignof(long long);
                    size = sizeof(long long);
                    break;
                case 'P':
                case 'O':
                case 'S':
                    align = alignof(void *);
                    size = sizeof(void *);
                    break;
                case 'e':
                    align = 2;
                    size = 2;
                    break;
                case 'f':
                    align = alignof(float);
                    size = sizeof(float);
                    break;
                case 'd':
                    align = alignof(double);
                    size = sizeof(double);
                    break;
            }
        }
    }

    if (size == 0) {
   
        mp_raise_ValueError(MP_ERROR_TEXT("bad typecode"));
    }

    if (palign != NULL) {
   
        *palign = align;
    }
    return size;
}

#if MICROPY_PY_BUILTINS_FLOAT && MICROPY_FLOAT_USE_NATIVE_FLT16

static inline float mp_decode_half_float(uint16_t hf) {
   
    union {
   
        uint16_t i;
        _Float16 f;
    } fpu = {
    .i = hf };
    return fpu.f;
}

static inline uint16_t mp_encode_half_float(float x) {
   
    union {
   
        uint16_t i;
        _Float16 f;
    } fp_sp = {
    .f = (_Float16)x };
    return fp_sp.i;
}

#elif MICROPY_PY_BUILTINS_FLOAT

static float mp_decode_half_float(uint16_t hf) {
   
    union {
   
        uint32_t i;
        float f;
    } fpu;

    uint16_t m = hf & 0x3ff;
    int e = (hf >> 10) & 0x1f;
    if (e