# final-mod

**Repository Path**: zinface/final-mod

## Basic Information

- **Project Name**: final-mod
- **Description**: 基于FinalC 规则构建的 FinalMod，模块加载器
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-11-12
- **Last Updated**: 2022-05-26

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# FinalMod

FinalMod 基于 FinalC 规则内建有关动态扩展库加载部分


## 测试示例

1. 使用 FinalMod_Module_MetaData 宏定义模块元数据
2. 使用 FinalMod_Module_WrapData 宏定义模块包装数据
3. 使用 FinalMod 内建模块描述器 ModStruct 进行处理模块的加载
    * createModStructWithMeta: 创建模块描述器，
    * modStructLoader: 通过描述器尝试加载模块 - 如果模块加载成功将返回true
    * modStructUnloader: 通过描述器尝试卸载模块
    * modStructLoaderFinalModMeta：通过描述器尝试加载模块元数据信息 - 如果模块已经定义并且找到将返回 true
    * modStructLoaderFinalModWrap：通过描述器尝试加载模块包装数据信息 - 如果模块已经定义并且找到将返回 true
    * modStructLoaderSym： 同等 dlsym() 函数，通过描述器尝试加载模块中自定数据符号 - 不建议使用，基于 FinalMod 操作时应该尽可能不使用类标准库方式，

### 1. 来自 helloworld 提供的示例代码

1. 自定义模块内部信息
    ```c
    #include "FinalMod.h"

    // 您可以使用更简单的数据
    char str[] = "Hello World";

    FinalMod_Module_WrapData("hello", "A simple string", str);
    FinalMod_Module_MetaData("hello", "The Hello module description (metadata) provides only one string of data", "0.1")
    ```

2. 尝试使用 FinalMod 内建操作集进行操作
    ```c
    #include "ModBuildin.h"

    #include <stdio.h>

    int	main(int argc, char **argv)
    {
        printf("Welcome to Final Mod!\n");

        ModStruct *hello_ms = createModStructWithMeta("./libhello.so", "hello");

        // 尝试加载 hello 模块
        if (modStructLoader(hello_ms)) {
            // 尝试加载 hello 模块的元数据
            if(modStructLoaderFinalModMeta(hello_ms)) {
                printf("%s Meta 加载成功: %s\n", hello_ms->name, hello_ms->meta->meta_descript);
            }
            // 尝试加载 hello 模块的包装数据
            if (modStructLoaderFinalModWrap(hello_ms)) {
                printf("%s Wrap 加载成功: %s\n", hello_ms->name, hello_ms->wrap->wrap_name);

                // 打印 hello 模块的包装数据: char str[] = "Hello World";
                printf("%s\n",(char*)hello_ms->wrap->wrap_data);
            }
        }

        // 卸载模块
        modStructUnloader(hello_ms);

        return 0;
    }


    // Output:
    // Welcome to Final Mod!
    // hello Meta 加载成功: The Hello module description (metadata) provides only one string of data
    // hello Wrap 加载成功: hello
    // Hello World
    ```

### 2. 来自 Welcome 提供的示例代码

1. 使用 common.h 创建基于 FinalC 规则的数据结构定义
    ```c
    #ifndef __COMMON__H__
    #define __COMMON__H__

    #include "FinalMod.h"

    FinalC_Object_Define(WelStruct) {
        const char *hello;
        const char *bye;
        void (*welcomeFunc)();
        void (*goodbyeFunc)();
    };
    FinalC_Object_Conv(WelStruct);

    #endif  //!__COMMON__H__
    ```

2. 在 welcome 模块中提供基于 WelStruct 结构信息
    ```c
    #include "FinalMod.h"

    #include "common.h"

    #include <stdio.h>

    static void sayHello();
    static void sayBye();

    WelStruct welcome = {
        .hello = "======== Welcome to FinalMod ========",
        .bye = "======== Goodle bye FinalMod ========",
        .welcomeFunc = sayHello,
        .goodbyeFunc = sayBye
    };

    static void sayHello() {
        printf("welcome: %s\n", welcome.hello);
    }
    static void sayBye() {
        printf("welcome: %s\n", welcome.bye);
    }


    FinalMod_Module_WrapData("welcome", "welcome string", &welcome)
    FinalMod_Module_MetaData("welcome", "base finalmod defined.", "1")

    // 你也可以使用更简单的数据
    // char str[] = "Hello World";
    // FinalMod_Module_WrapData("hello", "A simple string", str);
    ```

3. 在测试主程序中使用内建数据加载器加载 welcome 模块
    ```c
    #include "ModBuildin.h"

    #include "common.h"

    #include <stdio.h>

    int	main(int argc, char **argv)
    {
        ModStruct *welcome_ms = createModStructWithMeta("./libwelcome.so", "welcome");

        // 尝试加载 welcome 模块
        if (modStructLoader(welcome_ms)) {
            // 尝试加载 welcome 模块的元数据
            if(modStructLoaderFinalModMeta(welcome_ms)) {
                // printf("%s Meta 加载成功: %s\n", welcome_ms->name, welcome_ms->meta->meta_descript);
            }
            // 尝试加载 welcome 模块的包装数据: WelStruct
            if (modStructLoaderFinalModWrap(welcome_ms)) {
                // printf("%s Wrap 加载成功: %s\n", welcome_ms->name, welcome_ms->wrap->wrap_name);

                // 转换wrap包装数据的数据部分到 WelStruct 
                WelStruct *wel = convWelStruct(welcome_ms->wrap->wrap_data);

                // 打印 welcome 模块的包装数据: WelStruct
                printf("--> %s\n"
                    "--> %s\n",wel->hello, wel->bye);

                // 尝试调用 welcome 模块包装数据提供的方法
                wel->welcomeFunc();
                wel->goodbyeFunc();
            }
        }

        // 卸载模块
        modStructUnloader(welcome_ms);

        return 0;
    }

    // Output:
    // --> ======== Welcome to FinalMod ========
    // --> ======== Goodle bye FinalMod ========
    // welcome: ======== Welcome to FinalMod ========
    // welcome: ======== Goodle bye FinalMod ========

    ```