自制编程语言crowbar(v0.1)构建解析器时分配内存

crowbar中第一次申请内存是在生成解析器的时候：

/* interface.c */
CRB_Interpreter *CRB_create_interpreter(void)
{
    MEM_Storage storage;
    CRB_Interpreter *interpreter;

    storage = MEM_open_storage();
    interpreter = MEM_storage_malloc(storage,
                                     sizeof(struct CRB_Interpreter_tag));
    interpreter->interpreter_storage = storage;
    interpreter->execute_storage = NULL;
    interpreter->variable = NULL;
    interpreter->function_list = NULL;
    interpreter->statement_list = NULL;
    interpreter->current_line_number = ;

    crb_set_current_interpreter(interpreter);
    add_native_functions(interpreter);

    return interpreter;
}

首先看一下MEM_Storage类型，声明：

/* MEM.h */
typedef struct MEM_Storage_tag *MEM_Storage;

/* MEM/storage.c */
struct MEM_Storage_tag {
    MemoryPageList      page_list;
    int                 current_page_size;
};

typedef MemoryPage *MemoryPageList;

typedef struct MemoryPage_tag MemoryPage;

struct MemoryPage_tag {
    int                 cell_num;
    int                 use_cell_num;
    MemoryPageList      next;
    Cell                cell[];
};

typedef union {
    long        l_dummy;
    double      d_dummy;
    void        *p_dummy;
} Cell;

结构图：（cell是union）

aaarticlea/png;base64,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" alt="" />

再接着看MEM_open_storage(0)：

/* MEM.h */
#define MEM_open_storage(page_size)(MEM_open_storage_func(MEM_CURRENT_CONTROLLER,  __FILE__, __LINE__, page_size))

/* MEM/storage.c */
MEM_Storage MEM_open_storage_func(MEM_Controller controller,char *filename, int line, int page_size)
{
    MEM_Storage storage;

    storage = MEM_malloc_func(controller, filename, line,
                              sizeof(struct MEM_Storage_tag));
    storage->page_list = NULL;
    assert(page_size >= );
    if (page_size > ) {
        storage->current_page_size = page_size;
    } else {
        storage->current_page_size = DEFAULT_PAGE_SIZE;
    }

    return storage;
}

MEM_open_storage函数传了一个MEM_CURRENT_CONTROLLER宏，那接下来看一下这个宏定义：

/* MEM.h */
typedef struct MEM_Controller_tag *MEM_Controller;

extern MEM_Controller mem_default_controller;

#ifdef MEM_CONTROLLER
#define MEM_CURRENT_CONTROLLER MEM_CONTROLLER
#else /* MEM_CONTROLLER */
#define MEM_CURRENT_CONTROLLER mem_default_controller
#endif /* MEM_CONTROLLER */

　MEM_Controller_tag的定义：

/* MEM/memory.h */
typedef union Header_tag Header;

struct MEM_Controller_tag {
    FILE        *error_fp;
    MEM_ErrorHandler    error_handler;
    MEM_FailMode        fail_mode;
    Header      *block_header;
};

/* MEM.h */
typedef void (*MEM_ErrorHandler)(MEM_Controller, char *, int, char *);

typedef enum {
    MEM_FAIL_AND_EXIT,
    MEM_FAIL_AND_RETURN
} MEM_FailMode;

　　其中Header_tag定义：

/* MEM/memory.c */
union Header_tag {
    HeaderStruct        s;
    Align               u[HEADER_ALIGN_SIZE];
};

#define MARK_SIZE       (4)
#define ALIGN_SIZE      (sizeof(Align))
#define revalue_up_align(val)   ((val) ? (((val) - 1) / ALIGN_SIZE + 1) : 0)
#define HEADER_ALIGN_SIZE       (revalue_up_align(sizeof(HeaderStruct)))
#define MARK (0xCD)

typedef struct {
    int         size;
    char        *filename;
    int         line;
    Header      *prev;
    Header      *next;
    unsigned char       mark[MARK_SIZE];
} HeaderStruct;

typedef union {
    long        l_dummy;
    double      d_dummy;
    void        *p_dummy;
} Align;

可以看到在MEM_open_storage_func()中调用了MEM_malloc_func(),MEM_malloc_func原型：

/* MEM/memory.c */
void *MEM_malloc_func(MEM_Controller controller, char *filename, int line, size_t size)
{
    void        *ptr;
    size_t      alloc_size;

#ifdef DEBUG
    alloc_size = size + sizeof(Header) + MARK_SIZE;
#else
    alloc_size = size;
#endif
    ptr = malloc(alloc_size);
    if (ptr == NULL) {
        error_handler(controller, filename, line, "malloc");
    }
#ifdef DEBUG
    memset(ptr, 0xCC, alloc_size);
    set_header(ptr, size, filename, line);
    set_tail(ptr, alloc_size);
    chain_block(controller, (Header*)ptr);
    ptr = (char*)ptr + sizeof(Header);
#endif

    return ptr;
}

其中的DEBUG代码暂时先不管。那到这里为止已经从内存中申请了DEFAULT_PAGE_SIZE（1024）大小的内存给了MEM_Storage storage变量

接着看 interpreter = MEM_storage_malloc(storage, sizeof(struct CRB_Interpreter_tag));

MEM_storage_malloc原型：

/* MEM.h */
#define MEM_storage_malloc(storage, size) (MEM_storage_malloc_func(MEM_CURRENT_CONTROLLER,__FILE__, __LINE__, storage, size))

/* MEM/storage.c */
void *MEM_storage_malloc_func(MEM_Controller controller, char *filename, int line, MEM_Storage storage, size_t size)
{
    int                 cell_num;
    MemoryPage          *new_page;
    void                *p;

    cell_num = ((size - ) / CELL_SIZE) + ;
　　/* 如果storage中已经用到的cell加上将要分配的cell小于storage中所有的cell则从storage中取出一个cell返回 */
    if (storage->page_list != NULL
        && (storage->page_list->use_cell_num + cell_num
            < storage->page_list->cell_num)) {
        p = &(storage->page_list->cell[storage->page_list->use_cell_num]);
        storage->page_list->use_cell_num += cell_num;
　　/* 否则则重新从内存中申请 */
    } else {
        int     alloc_cell_num;

        alloc_cell_num = larger(cell_num, storage->current_page_size);

        new_page = MEM_malloc_func(controller, filename, line,
                                   sizeof(MemoryPage)
                                   + CELL_SIZE * (alloc_cell_num - ));
        new_page->next = storage->page_list;
        new_page->cell_num = alloc_cell_num;
        storage->page_list = new_page;

        p = &(new_page->cell[]);
        new_page->use_cell_num = cell_num;
    }

    return p;
}

到此解析器的构建中内存分配已分析完