refactor & fix: 重构tool层模块

CMakeLists.txt

@@ -119,82 +119,82 @@ include(${CMAKE_CURRENT_LIST_DIR}/lang/hgt.cmake)  # 安装lang库
 add_subdirectory(src)
 include(aFunHeader)
 
-install(EXPORT aFunlang
-        NAMESPACE "aFunlang::"
-        DESTINATION ${INSTALL_CMAKEDIR}
-        COMPONENT dev)
-
-include(CMakePackageConfigHelpers)
-write_basic_package_version_file(${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfigVersion.cmake
-                                 VERSION ${aFunVersion}
-                                 COMPATIBILITY SameMinorVersion)
-
-# 生成Config.cmake文件
-set(INSTALL_DIR ${CMAKE_INSTALL_PREFIX})
-set(BINDIR ${INSTALL_BINDIR})
-set(LIBDIR ${INSTALL_LIBDIR})
-set(CMAKEDIR ${INSTALL_CMAKEDIR})
-set(INCLUDEDIR ${INSTALL_INCLUDEDIR})
-
-if (MSVC)
-    set(pthread_INSTALL_DIR ${deps_install_dir})
-    set(pthread_CMAKEDIR pthread_cmake)
-    set(path_var pthread_INSTALL_DIR pthread_CMAKEDIR)
-else()
-    set(path_var)
-endif()
-if (WIN32 AND NOT CYGWIN)  # cygwin 不需要编译 dl
-    foreach(tgt dlfcn pcre2 fflags)
-        set(${tgt}_INSTALL_DIR ${deps_install_dir})
-        set(${tgt}_CMAKEDIR ${deps_install_dir}/${${tgt}_cmake})
-        list(APPEND path_var ${tgt}_INSTALL_DIR ${tgt}_CMAKEDIR)
-    endforeach()
-else()
-    foreach(tgt pcre2 fflags)
-        set(${tgt}_INSTALL_DIR ${deps_install_dir})
-        set(${tgt}_CMAKEDIR ${deps_install_dir}/${${tgt}_cmake})
-        list(APPEND path_var ${tgt}_INSTALL_DIR ${tgt}_CMAKEDIR)
-    endforeach()
-
-    set(dlfcn_INSTALL_DIR \"\")  # 空字符串
-    set(dlfcn_CMAKEDIR \"\")  # 空字符串
-endif()
-
-configure_package_config_file(${PROJECT_SOURCE_DIR}/cmake/aFunlangConfig.cmake.in
-                              ${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfig.cmake
-                              INSTALL_DESTINATION ${INSTALL_CMAKEDIR}
-                              PATH_VARS INSTALL_DIR BINDIR LIBDIR CMAKEDIR INCLUDEDIR ${path_var}
-                              INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})  # 指定安装目录 (用于生成相对路径)
-unset(INSTALL_DIR)
-unset(BINDIR)
-unset(LIBDIR)
-unset(CMAKEDIR)
-unset(INCLUDEDIR)
-foreach(tgt dlfcn pcre2 fflags)
-    unset(${tgt}_INSTALL_DIR)
-    unset(${tgt}_CMAKEDIR)
-endforeach()
-unset(path_var)
-
-install(FILES
-        ${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfig.cmake
-        ${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfigVersion.cmake
-        DESTINATION ${INSTALL_CMAKEDIR})
-
-function(install_directory dir)
-    file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/${dir})  # 安装log输出的目录
-    install(CODE "file(MAKE_DIRECTORY ${CMAKE_INSTALL_PREFIX}/${dir})")  # 创建log目录
-endfunction()
-
-install_directory(${INSTALL_LOGDIR})
-install_directory(${INSTALL_LOCALSTATEDIR})
-install_directory(${INSTALL_LANGDIR})
-
+#install(EXPORT aFunlang
+#        NAMESPACE "aFunlang::"
+#        DESTINATION ${INSTALL_CMAKEDIR}
+#        COMPONENT dev)
+#
+#include(CMakePackageConfigHelpers)
+#write_basic_package_version_file(${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfigVersion.cmake
+#                                 VERSION ${aFunVersion}
+#                                 COMPATIBILITY SameMinorVersion)
+#
+## 生成Config.cmake文件
+#set(INSTALL_DIR ${CMAKE_INSTALL_PREFIX})
+#set(BINDIR ${INSTALL_BINDIR})
+#set(LIBDIR ${INSTALL_LIBDIR})
+#set(CMAKEDIR ${INSTALL_CMAKEDIR})
+#set(INCLUDEDIR ${INSTALL_INCLUDEDIR})
+#
+#if (MSVC)
+#    set(pthread_INSTALL_DIR ${deps_install_dir})
+#    set(pthread_CMAKEDIR pthread_cmake)
+#    set(path_var pthread_INSTALL_DIR pthread_CMAKEDIR)
+#else()
+#    set(path_var)
+#endif()
+#if (WIN32 AND NOT CYGWIN)  # cygwin 不需要编译 dl
+#    foreach(tgt dlfcn pcre2 fflags)
+#        set(${tgt}_INSTALL_DIR ${deps_install_dir})
+#        set(${tgt}_CMAKEDIR ${deps_install_dir}/${${tgt}_cmake})
+#        list(APPEND path_var ${tgt}_INSTALL_DIR ${tgt}_CMAKEDIR)
+#    endforeach()
+#else()
+#    foreach(tgt pcre2 fflags)
+#        set(${tgt}_INSTALL_DIR ${deps_install_dir})
+#        set(${tgt}_CMAKEDIR ${deps_install_dir}/${${tgt}_cmake})
+#        list(APPEND path_var ${tgt}_INSTALL_DIR ${tgt}_CMAKEDIR)
+#    endforeach()
+#
+#    set(dlfcn_INSTALL_DIR \"\")  # 空字符串
+#    set(dlfcn_CMAKEDIR \"\")  # 空字符串
+#endif()
+#
+#configure_package_config_file(${PROJECT_SOURCE_DIR}/cmake/aFunlangConfig.cmake.in
+#                              ${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfig.cmake
+#                              INSTALL_DESTINATION ${INSTALL_CMAKEDIR}
+#                              PATH_VARS INSTALL_DIR BINDIR LIBDIR CMAKEDIR INCLUDEDIR ${path_var}
+#                              INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})  # 指定安装目录 (用于生成相对路径)
+#unset(INSTALL_DIR)
+#unset(BINDIR)
+#unset(LIBDIR)
+#unset(CMAKEDIR)
+#unset(INCLUDEDIR)
+#foreach(tgt dlfcn pcre2 fflags)
+#    unset(${tgt}_INSTALL_DIR)
+#    unset(${tgt}_CMAKEDIR)
+#endforeach()
+#unset(path_var)
+#
+#install(FILES
+#        ${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfig.cmake
+#        ${CMAKE_BINARY_DIR}/cmake-tmp/aFunlangConfigVersion.cmake
+#        DESTINATION ${INSTALL_CMAKEDIR})
+#
+#function(install_directory dir)
+#    file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/${dir})  # 安装log输出的目录
+#    install(CODE "file(MAKE_DIRECTORY ${CMAKE_INSTALL_PREFIX}/${dir})")  # 创建log目录
+#endfunction()
+#
+#install_directory(${INSTALL_LOGDIR})
+#install_directory(${INSTALL_LOCALSTATEDIR})
+#install_directory(${INSTALL_LANGDIR})
+#
 set(BUILD_TEST FALSE CACHE BOOL "Enable run test program")
 set(_build_test ${BUILD_TEST})
 if (_build_test)
     enable_testing()
 endif()
 add_subdirectory(test)  # test的相关内容仍会被构建
-
-include(info)
+#
+#include(info)

cmake/aFunHeader.cmake

@@ -5,24 +5,34 @@ generate_export_header(tool-shared
                        EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/${INSTALL_INCLUDEDIR}/aFunToolExport.h"  # 导出的位置
                        BASE_NAME "AFUN_TOOL")
 
-generate_export_header(core-shared
-                       EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/${INSTALL_INCLUDEDIR}/aFunCoreExport.h"  # 导出的位置
-                       BASE_NAME "AFUN_CORE")
-
-generate_export_header(rt-shared
-                       EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/${INSTALL_INCLUDEDIR}/aFunlangExport.h"  # 导出的位置
-                       BASE_NAME "AFUN_LANG")
+#generate_export_header(core-shared
+#                       EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/${INSTALL_INCLUDEDIR}/aFunCoreExport.h"  # 导出的位置
+#                       BASE_NAME "AFUN_CORE")
+#
+#generate_export_header(rt-shared
+#                       EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/${INSTALL_INCLUDEDIR}/aFunlangExport.h"  # 导出的位置
+#                       BASE_NAME "AFUN_LANG")
 
 target_compile_definitions(tool-static PUBLIC AFUN_TOOL_STATIC_DEFINE=1)  # 静态库需要定义 AFUN_TOOL_STATIC_DEFINE
-target_compile_definitions(core-static PUBLIC AFUN_CORE_STATIC_DEFINE=1)
-target_compile_definitions(rt-static PUBLIC AFUN_LANG_STATIC_DEFINE=1)
-
-set_property(TARGET tool-shared core-shared rt-shared
+#target_compile_definitions(core-static PUBLIC AFUN_CORE_STATIC_DEFINE=1)
+#target_compile_definitions(rt-static PUBLIC AFUN_LANG_STATIC_DEFINE=1)
+#
+set_property(TARGET tool-shared
              PROPERTY C_VISIBILITY_PRESET "hidden")
-set_property(TARGET tool-shared core-shared rt-shared
+set_property(TARGET tool-shared
              PROPERTY VISIBILITY_INLINES_HIDDEN TRUE)
 
-set_property(TARGET tool-static core-static rt-static
+set_property(TARGET tool-static
              PROPERTY C_VISIBILITY_PRESET "default")
-set_property(TARGET tool-static core-static
-             PROPERTY VISIBILITY_INLINES_HIDDEN FALSE)
+set_property(TARGET tool-static
+             PROPERTY VISIBILITY_INLINES_HIDDEN FALSE)
+
+#set_property(TARGET tool-shared core-shared rt-shared
+#             PROPERTY C_VISIBILITY_PRESET "hidden")
+#set_property(TARGET tool-shared core-shared rt-shared
+#             PROPERTY VISIBILITY_INLINES_HIDDEN TRUE)
+#
+#set_property(TARGET tool-static core-static rt-static
+#             PROPERTY C_VISIBILITY_PRESET "default")
+#set_property(TARGET tool-static core-static
+#             PROPERTY VISIBILITY_INLINES_HIDDEN FALSE)

include/aFun.hpp

@@ -1,7 +0,0 @@
-#ifndef AFUN_AFUN_HPP
-#define AFUN_AFUN_HPP
-#include "aFunCore.hpp"
-#include "aFunlang.hpp"
-#include "tool.hpp"
-
-#endif //AFUN_AFUN_HPP

include/core/README

@@ -1,248 +0,0 @@
-aFun-core 的导出函数
-==================
-此处记录了aFun-Core模块导出的所有函数, 以及对应结构体解释
-
-core_init:
-* aFunCoreInit 初始化 全局应用程序
-
-
-code:
-af_Code 表示语法结构
-af_BlockType 表示block类型的枚举体 (公开)
-因为需要af_Code不能轻易修改, 因此不完全公开
-
-创建与释放：
-* makeElementCode
-* makeBlockCode
-* freeAllCode
-
-相关操作:：
-* pushCode  [不会修改现有代码的结构, 只是在末尾追加内容]
-* copyCode
-* writeAllCode
-* readAllCode
-* codeToStr
-
-属性访问:
-* getCodeNext
-* getCodeBlockElement
-* getCodeType
-* getCodeBlockType
-* getCodePrefix
-* getCodeEndCount
-* getCodeElementData
-* getCodeElementCount
-
-
-func
-af_ArgCodeList  表示参数计算表, 已经计算结果
-af_ArgList  表示参数赋值表
-af_FuncBody  函数体信息 [无访问的必要性]
-af_FuncInfo  函数信息 [无访问的必要性]
-
-创建与释放
-* makeArgCodeList
-* freeAllArgCodeList
-* makeArgList
-* freeAllArgList
-
-* makeCodeFuncBody
-* makeImportFuncBody
-* makeCFuncBody
-* makeDynamicFuncBody
-* freeFuncBody
-* freeAllFuncBody
-* makeFuncInfo
-* freeFuncInfo
-
-相关操作:
-* pushArgCodeList
-* pushArgList
-* pushFuncBody
-* makeCFuncBodyToFuncInfo
-* makeCodeFuncBodyToFuncInfo
-* makeImportFuncBodyToFuncInfo
-* makeDynamicFuncBodyToFuncInfo
-
-属性访问
-* getArgCodeListNext
-* getArgListNext
-* getArgCodeListResult
-* getArgCodeListData
-* getArgCodeListRunInFunc
-
-
-gc
-GcList 记录自定义的gc链接信息 [无访问的必要性]
-
-创建与释放
-* makeGcList
-* freeAllGcList
-
-相关操作:
-* pushGcList
-* gc_addObjectReference
-* gc_addVarReference
-* gc_addVarSpaceReference
-* gc_delObjectReference
-* gc_delVarReference
-* gc_delVarSpaceReference
-
-属性访问
-* gc_getObjectReference
-* gc_getVarReference
-* gc_getVarSpaceReference
-
-
-object
-af_Object 描述一个对象
-af_Inherit 描述继承关系
-af_ObjectAPI 描述API
-
-创建与释放
-* makeObject
-* makeInherit
-* freeAllInherit
-* makeObjectAPI
-* freeObjectAPI
-
-相关操作:
-* objectSetAllowInherit
-* setObjectAttributes
-* addAPI
-* addAPIToObject
-* pushInherit
-
-属性访问
-* getObjectID
-* getObjectData
-* getObjectAPI
-* getBelongObject
-* getObjectInherit
-* getInheritNext
-* findObjectAttributes
-* checkPosterity
-* getInheritObject
-* getInheritVarSpace
-* findAPI
-* findObjectAPI
-* getAPICount
-
-
-parser
-af_Parser 描述解释器
-
-创建与释放:
-* makeParser
-* freeParser
-* makeParserByString
-* makeParserByFile
-* makeParserByStdin
-
-相关操作:
-* parserCode
-* initParser
-
-
-run
-相关操作:
-* iterCode
-
-var
-af_Var 描述一个变量
-af_VarSpace 描述一个变量空间
-af_VarList 描述变量空间链
-
-创建与释放:
-* makeVar
-* makeVarSpace
-* makeVarSpaceList
-* freeAllVarSpaceList
-* freeVarSpaceListCount
-
-相关操作:
-* addVarNode
-* addVarToVarSpace
-* makeVarToVarSpace
-* addVarToVarSpaceList
-* makeVarToVarSpaceList
-* makeVarToProtectVarSpace
-* delVarFromVarSpace
-* delVarFromVarList
-* setVarToVarSpace
-* setVarToVarList
-* pushNewVarList
-* setVarPermissions
-* setVarSpacePermissions
-* setVarSpaceProtect
-
-属性访问
-* isProtectVarSpace
-* findVarNode
-* findVarFromVarSpace
-* findVarFromVarList
-* getVarSpaceFromList
-
-
-env
-af_Environment 描述运行环境
-af_Message 描述消息传递
-af_ErrorInfo 描述错误信息
-
-创建与释放
-* makeEnvironment
-* freeEnvironment
-* makeMessage
-* freeMessage
-* freeMessageCount
-* makeNORMALMessage
-* makeERRORMessage
-* makeERRORMessageFormat
-* makeIMPORTMessage
-* makeErrorInfo
-* freeErrorInfo
-* makeImportInfo
-* freeImportInfo
-
-相关操作:
-* enableEnvironment
-* setGcMax
-* setGcRun
-* setPrefix
-* addVarToProtectVarSpace
-* setCoreStop
-* setCoreExit
-* setCoreNormal
-* pushMessageUp
-* popMessageUpData
-* popMessageUp
-* pushMessageDown
-* popMessageDown
-* setEnvVarData
-* addTopMsgProcess
-* pushLiteralRegex
-* fprintfErrorInfo
-* pushErrorBacktracking
-
-属性访问
-* getPrefix
-* getBaseObject
-* getProtectVarSpace
-* getMessageData
-* getFirstMessage
-* getGcCount
-* getGcMax
-* getGcRun
-* getCoreGlobal
-* getGlobal (会涉及import)
-* getBelong
-* getActivityFile
-* getActivityLine
-* findEnvVarData
-* getMsgNormalData
-* getMsgErrorInfo
-* getMsgImportInfo
-* getErrorType
-* getError
-* getImportMark
-* getImportObject

include/core/aFunCore.hpp

@@ -1,29 +0,0 @@
-#ifndef AFUN_AFUNCORE_HPP
-#define AFUN_AFUNCORE_HPP
-#include "aFunCoreExport.h"
-#include "tool.hpp"
-
-#include "magic_func.h"
-#include "prefix_macro.h"
-#include "obj_api.h"
-
-#include "parserl_warning_error.h"
-#include "runtime_error.h"
-
-#include "core_init.hpp"
-#include "sig.hpp"
-#include "run.hpp"
-#include "code.hpp"
-#include "bytecode.hpp"
-#include "env.hpp"
-#include "gc.hpp"
-#include "func.hpp"
-#include "object.hpp"
-#include "var.hpp"
-#include "parser.hpp"
-#include "reader.hpp"
-#include "token.h"
-#include "global_obj.hpp"
-#include "thread.hpp"
-
-#endif //AFUN_AFUNCORE_HPP

include/core/bytecode.hpp

@@ -1,10 +0,0 @@
-#ifndef AFUN_BYTECODE_HPP
-#define AFUN_BYTECODE_HPP
-
-AFUN_CORE_EXPORT extern char const * const writeByteCodeError[5];
-AFUN_CORE_EXPORT extern char const * const readByteCodeError[7];
-
-AFUN_CORE_EXPORT int readByteCode(af_Code **code, ConstFilePath path);
-AFUN_CORE_EXPORT int writeByteCode(af_Code *code, ConstFilePath path);
-
-#endif //AFUN_BYTECODE_HPP

include/core/code.hpp

@@ -1,50 +0,0 @@
-#ifndef AFUN_BYTECODE
-#define AFUN_BYTECODE
-#include <stdio.h>
-#include "aFunCoreExport.h"
-
-#define CODE_STR_MAX_SIZE (50)
-typedef struct af_Code af_Code;
-
-typedef uint32_t CodeUInt;  // Code int
-typedef int64_t LayerInt;  // 只有当layer会小于0时使用
-
-enum af_CodeType {
-    code_element = 'e',
-    code_block = 'm',  // 括号
-};
-
-/* 括号类型 */
-enum af_BlockType {
-    parentheses = '(',  // 小括号
-    brackets = '[',  // 中括号
-    curly = '{',  // 大括号
-};
-
-/* 代码块 创建与释放 */
-AFUN_CORE_EXPORT af_Code *makeElementCode(const char *var, char prefix, FileLine line, ConstFilePath path);
-AFUN_CORE_EXPORT af_Code *makeBlockCode(enum af_BlockType type, af_Code *element, char prefix,
-                                        FileLine line, ConstFilePath path, af_Code **next);
-AFUN_CORE_EXPORT void freeAllCode(af_Code *bt);
-
-/* 代码块 相关操作 */
-AFUN_CORE_EXPORT af_Code *pushCode(af_Code **base, af_Code *next);
-AFUN_CORE_EXPORT af_Code *copyAllCode(af_Code *base, ConstFilePath path);
-AFUN_CORE_EXPORT af_Code *copyCode(af_Code *base);
-AFUN_CORE_EXPORT bool writeAllCode(af_Code *bt, FILE *file);
-AFUN_CORE_EXPORT bool readAllCode(af_Code **bt, ConstFilePath path, FILE *file);
-
-/* 代码块 属性访问 */
-AFUN_CORE_EXPORT af_Code *getCodeNext(af_Code *bt);
-AFUN_CORE_EXPORT af_Code *getCodeElement(af_Code *bt);
-AFUN_CORE_EXPORT char *codeToStr(af_Code *code, int n);
-AFUN_CORE_EXPORT enum af_CodeType getCodeType(af_Code *code);
-AFUN_CORE_EXPORT enum af_BlockType getCodeBlockType(af_Code *code);
-AFUN_CORE_EXPORT char getCodePrefix(af_Code *code);
-AFUN_CORE_EXPORT CodeUInt getCodeEndCount(af_Code *code);
-AFUN_CORE_EXPORT char *getCodeElementData(af_Code *code);
-AFUN_CORE_EXPORT CodeUInt getCodeElementCount(af_Code *code);
-AFUN_CORE_EXPORT char *getCodeMD5(af_Code *code);
-AFUN_CORE_EXPORT bool codeSemanticCheck(af_Code *code);
-AFUN_CORE_EXPORT void printCode(af_Code *bt);
-#endif //AFUN_BYTECODE

include/core/core_init.hpp

@@ -1,30 +0,0 @@
-#ifndef AFUN_INIT_H
-#define AFUN_INIT_H
-#include "aFunCoreExport.h"
-#include <setjmp.h>
-#include "macro.hpp"
-#include "sig.hpp"
-#include "tool.hpp"
-
-typedef struct aFunCoreInitInfo aFunCoreInitInfo;
-struct aFunCoreInitInfo {
-    const char *base_dir;
-
-    bool log_asyn;
-    jmp_buf *buf;
-    LogLevel level;
-};
-
-typedef struct aFunRunCoreInfo aFunRunCoreInfo;
-struct aFunRunCoreInfo {
-    bool signal;
-};
-
-AFUN_CORE_EXPORT extern Logger *aFunCoreLogger;
-AFUN_CORE_EXPORT bool aFunCoreInit(aFunCoreInitInfo *info);
-AFUN_CORE_EXPORT bool aFunCoreDestruct(void);
-
-AFUN_CORE_EXPORT void defineRunEnvCore(aFunRunCoreInfo *run_env);
-AFUN_CORE_EXPORT void undefRunEnvCore(aFunRunCoreInfo *run_env);
-
-#endif //AFUN_INIT_H

include/core/env.hpp

@@ -1,136 +0,0 @@
-#ifndef AFUN_ENV
-#define AFUN_ENV
-#include "aFunCoreExport.h"
-#include "tool.hpp"
-#include "prefix_macro.h"
-
-typedef struct af_Environment af_Environment;
-typedef struct af_Message af_Message;
-typedef struct af_ErrorInfo af_ErrorInfo;
-typedef struct af_ImportInfo af_ImportInfo;
-typedef struct af_GuardianList af_GuardianList, **paf_GuardianList;
-
-/* 顶层消息处理器的处理函数 DLC */
-typedef void TopMsgProcessFunc(af_Message *msg, bool is_top, af_Environment *env);
-DEFINE_DLC_SYMBOL(TopMsgProcessFunc);
-
-typedef af_GuardianList *GuardianFunc(const char *type, bool is_guard, void *data, af_Environment *env);
-DEFINE_DLC_SYMBOL(GuardianFunc);
-
-typedef void GuardianDestruct(const char *type, void *data, af_Environment *env);
-DEFINE_DLC_SYMBOL(GuardianDestruct);
-
-enum GcRunTime {
-    grt_always = 0,  // 总是运行
-    grt_count,  // 累计式运行
-};
-
-#include "code.hpp"
-#include "object.hpp"
-#include "var.hpp"
-
-/* 运行环境 创建与释放 */
-AFUN_CORE_EXPORT af_Environment *makeEnvironment(enum GcRunTime grt);
-AFUN_CORE_EXPORT bool freeEnvironment(af_Environment *env);
-AFUN_CORE_EXPORT af_Environment *deriveEnvironment(bool derive_tmp, bool derive_guardian, bool derive_lr, bool enable,
-                                                   af_Environment *base);
-
-/* 消息 创建与释放 */
-AFUN_CORE_EXPORT af_Message *makeMessage(const char *type, size_t size);
-AFUN_CORE_EXPORT af_Message *freeMessage(af_Message *msg);
-AFUN_CORE_EXPORT bool freeMessageCount(size_t count, af_Message *msg);
-AFUN_CORE_EXPORT af_Message *makeNORMALMessage(af_Object *obj, af_Environment *env);
-AFUN_CORE_EXPORT af_Message *makeERRORMessage(const char *type, const char *error, af_Environment *env);
-AFUN_CORE_EXPORT af_Message *makeERRORMessageFormat(const char *type, af_Environment *env, const char *format, ...);
-AFUN_CORE_EXPORT af_Message *makeIMPORTMessage(const char *mark, af_Object *obj, af_Environment *env);
-
-/* ErrorInfo 创建与释放 */
-AFUN_CORE_EXPORT af_ErrorInfo *makeErrorInfo(const char *type, const char *error, const char *note, FileLine line, FilePath path);
-AFUN_CORE_EXPORT void freeErrorInfo(af_ErrorInfo *ei, af_Environment *env);
-
-/* ImportInfo 创建与释放 */
-af_ImportInfo *makeImportInfo(const char *mark, af_Object *obj, af_Environment *env);
-void freeImportInfo(af_ImportInfo *ii, af_Environment *env);
-
-/* 运行环境 相关操作 */
-AFUN_CORE_EXPORT void enableEnvironment(af_Environment *env);
-AFUN_CORE_EXPORT void setGcMax(int32_t max, af_Environment *env);
-AFUN_CORE_EXPORT void setGcRun(enum GcRunTime grt, af_Environment *env);
-AFUN_CORE_EXPORT char setPrefix(size_t name, char prefix, af_Environment *env);
-AFUN_CORE_EXPORT void setCoreStop(af_Environment *env);
-AFUN_CORE_EXPORT void setCoreExit(int exit_code, af_Environment *env);
-AFUN_CORE_EXPORT void setCoreExitNotExitCode(af_Environment *env);
-AFUN_CORE_EXPORT void setCoreNormal(af_Environment *env);
-AFUN_CORE_EXPORT void setArgc(int argc, af_Environment *env);
-AFUN_CORE_EXPORT void setEnviromentExit_out(af_Environment *env);
-AFUN_CORE_EXPORT void waitForEnviromentExit(af_Environment *env);
-
-/* 消息 相关操作 */
-AFUN_CORE_EXPORT void pushMessageUp(af_Message *msg, af_Environment *env);
-AFUN_CORE_EXPORT void *popMessageUpData(const char *type, af_Environment *env);
-AFUN_CORE_EXPORT af_Message *popMessageUp(af_Environment *env);
-AFUN_CORE_EXPORT void *getMessageData(af_Message *msg);
-AFUN_CORE_EXPORT void pushMessageDown(af_Message *msg, af_Environment *env);
-AFUN_CORE_EXPORT af_Message *popMessageDown(const char *type, af_Environment *env);
-AFUN_CORE_EXPORT af_Message *getFirstMessage(af_Environment *env);
-
-/* 环境变量 相关操作 */
-AFUN_CORE_EXPORT void setEnvVarData(const char *name, const char *data, af_Environment *env);
-AFUN_CORE_EXPORT void setEnvVarNumber(const char *name, int32_t data, af_Environment *env);
-
-/* 顶层消息处理器 相关操作 */
-AFUN_CORE_EXPORT bool addTopMsgProcess(const char *type, DLC_SYMBOL(TopMsgProcessFunc) func, af_Environment *env);
-
-/* 顶层消息处理器 相关操作 */
-AFUN_CORE_EXPORT bool addGuardian(const char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
-                                  DLC_SYMBOL(GuardianDestruct) destruct, void **pdata, af_Environment *env);
-AFUN_CORE_EXPORT bool popGuardian(const char *type, af_Environment *env);
-
-/* LiteralRegex 相关操作 */
-AFUN_CORE_EXPORT bool pushLiteralRegex(const char *pattern, const char *func, bool in_protect, af_Environment *env);
-
-/* ErrorInfo 相关操作 */
-AFUN_CORE_EXPORT void fprintfErrorInfo(FILE *file, af_ErrorInfo *ei);
-AFUN_CORE_EXPORT void fprintfErrorInfoStderr(af_ErrorInfo *ei);
-AFUN_CORE_EXPORT void fprintfErrorInfoStdout(af_ErrorInfo *ei);
-
-/* ErrorBacktracking 相关操作 */
-AFUN_CORE_EXPORT void pushErrorBacktracking(FileLine line, FilePath file, const char *note, af_ErrorInfo *ei);
-
-/* GuardianList 相关操作 */
-AFUN_CORE_EXPORT void pushGuardianList(af_Object *obj, af_Object *func, paf_GuardianList &pal, af_Environment *env);
-
-/* 环境变量 属性访问 */
-AFUN_CORE_EXPORT char *findEnvVarData(const char *name, af_Environment *env);
-AFUN_CORE_EXPORT int32_t *findEnvVarNumber(const char *name, af_Environment *env);
-
-/* 运行环境 属性访问 */
-AFUN_CORE_EXPORT char getPrefix(size_t name, af_Environment *env);
-AFUN_CORE_EXPORT af_Object *getBaseObject(const char *name, af_Environment *env);
-AFUN_CORE_EXPORT af_VarSpace *getProtectVarSpace(af_Environment *env);
-AFUN_CORE_EXPORT int32_t getGcCount(af_Environment *env);
-AFUN_CORE_EXPORT int32_t getGcMax(af_Environment *env);
-AFUN_CORE_EXPORT enum GcRunTime getGcRun(af_Environment *env);
-AFUN_CORE_EXPORT int getArgc(af_Environment *env);
-AFUN_CORE_EXPORT af_Object *getCoreGlobal(af_Environment *env);
-AFUN_CORE_EXPORT af_Object *getGlobal(af_Environment *env);
-AFUN_CORE_EXPORT af_Object *getBelong(af_Environment *env);
-AFUN_CORE_EXPORT FilePath getActivityFile(af_Environment *env);
-AFUN_CORE_EXPORT FileLine getActivityLine(af_Environment *env);
-AFUN_CORE_EXPORT af_VarList *getRunVarSpaceList(af_Environment *env);
-AFUN_CORE_EXPORT int isCoreExit(af_Environment *env);
-AFUN_CORE_EXPORT bool getErrorStd(af_Environment *env);
-AFUN_CORE_EXPORT int32_t getCoreExitCode(af_Environment *env);
-AFUN_CORE_EXPORT af_Object *getActivityFunc(af_Environment *env);
-AFUN_CORE_EXPORT bool isEnviromentExit(af_Environment *env);
-AFUN_CORE_EXPORT size_t getEnviromentSonCount(af_Environment *env);
-
-/* ErrorInfo 属性访问 */
-AFUN_CORE_EXPORT char *getErrorType(af_ErrorInfo *ei);
-AFUN_CORE_EXPORT char *getError(af_ErrorInfo *ei);
-
-/* ImportInfo 属性访问 */
-AFUN_CORE_EXPORT char *getImportMark(af_ImportInfo *ii);
-AFUN_CORE_EXPORT af_Object *getImportObject(af_ImportInfo *ii, af_Environment *env);
-
-#endif //AFUN_ENV

include/core/func.hpp

@@ -1,90 +0,0 @@
-#ifndef AFUN_FUNC
-#define AFUN_FUNC
-typedef struct af_ArgCodeList af_ArgCodeList;
-typedef struct af_ArgList af_ArgList;
-typedef struct af_FuncInfo af_FuncInfo;
-typedef struct af_FuncBody af_FuncBody;
-
-enum af_FuncInfoScope {
-    normal_scope = 0,
-    inline_scope,
-    pure_scope,
-    super_pure_scope,
-};
-
-enum af_FuncInfoEmbedded {
-    not_embedded = 0,
-    protect_embedded,  // 内嵌函数
-    super_embedded,  // 超内嵌函数
-};
-
-#include "aFunCoreExport.h"
-#include "code.hpp"
-#include "object.hpp"
-
-typedef struct af_CallFuncInfo af_CallFuncInfo;
-struct af_CallFuncInfo {
-    void *mark;
-    af_FuncBody *body_next;
-
-    af_Object *belong;
-    af_Object *func;
-    struct af_VarList *var_list;
-
-    enum af_BlockType call_type;
-    bool is_gc_call;
-    bool is_literal;
-    bool is_obj_func;
-    bool is_macro_call;
-};
-
-typedef struct af_FuncBody *callFuncBody(af_CallFuncInfo *info, af_Environment *env);
-NEW_DLC_SYMBOL(callFuncBody, callFuncBody);
-
-/* af_ArgCodeList 创建与释放 */
-AFUN_CORE_EXPORT af_ArgCodeList *makeArgCodeList(af_Code *code, size_t size, bool free_code, bool run_in_func);
-AFUN_CORE_EXPORT void freeAllArgCodeList(af_ArgCodeList *acl, af_Environment *env);
-
-/* af_ArgList 创建与释放 */
-AFUN_CORE_EXPORT af_ArgList *makeArgList(char *name, af_Object *obj);
-AFUN_CORE_EXPORT void freeAllArgList(af_ArgList *al, af_Environment *env);
-AFUN_CORE_EXPORT af_ArgList *makeArgListFromArgCodeList(const char *name, af_ArgCodeList *acl, af_Environment *env);
-
-/* FuncBody 创建与释放 */
-AFUN_CORE_EXPORT af_FuncBody *makeCodeFuncBody(af_Code *code, bool free_code, char **msg_type);
-AFUN_CORE_EXPORT af_FuncBody *makeImportFuncBody(af_Code *code, bool free_code, char **msg_type);
-AFUN_CORE_EXPORT af_FuncBody *makeCFuncBody(DLC_SYMBOL(callFuncBody) c_func, char **msg_type);
-AFUN_CORE_EXPORT af_FuncBody *makeDynamicFuncBody();
-AFUN_CORE_EXPORT af_FuncBody *freeFuncBody(af_FuncBody *fb);
-AFUN_CORE_EXPORT void freeAllFuncBody(af_FuncBody *fb);
-
-/* FuncInfo 创建与释放 */
-AFUN_CORE_EXPORT af_FuncInfo *makeFuncInfo(enum af_FuncInfoScope scope, enum af_FuncInfoEmbedded embedded,
-                                           bool is_macro, bool var_this, bool var_func);
-AFUN_CORE_EXPORT void freeFuncInfo(af_FuncInfo *fi);
-
-/* af_ArgCodeList 相关操作 */
-AFUN_CORE_EXPORT af_ArgCodeList **pushArgCodeList(af_ArgCodeList **base, af_ArgCodeList *new_acl);
-
-/* af_ArgList 相关操作 */
-AFUN_CORE_EXPORT af_ArgList **pushArgList(af_ArgList **base, af_ArgList *new_al);
-
-/* af_FuncBody 相关操作 */
-AFUN_CORE_EXPORT void pushFuncBody(af_FuncBody **base, af_FuncBody *body);
-
-/* FuncInfo 相关操作 */
-AFUN_CORE_EXPORT af_FuncBody *makeCFuncBodyToFuncInfo(DLC_SYMBOL(callFuncBody) c_func, char **msg_type, af_FuncInfo *fi);
-AFUN_CORE_EXPORT af_FuncBody *makeCodeFuncBodyToFuncInfo(af_Code *code, bool free_code, char **msg_type, af_FuncInfo *fi);
-AFUN_CORE_EXPORT af_FuncBody *makeImportFuncBodyToFuncInfo(af_Code *code, bool free_code, char **msg_type, af_FuncInfo *fi);
-AFUN_CORE_EXPORT af_FuncBody *makeDynamicFuncBodyToFuncInfo(af_FuncInfo *fi);
-
-/* af_ArgCodeList 属性获取 */
-AFUN_CORE_EXPORT void *getArgCodeListData(af_ArgCodeList *acl);
-AFUN_CORE_EXPORT af_Object *getArgCodeListResult(af_ArgCodeList *acl);
-af_ArgCodeList *getArgCodeListNext(af_ArgCodeList *acl);
-bool getArgCodeListRunInFunc(af_ArgCodeList *acl);
-
-/* af_ArgList 属性获取 */
-af_ArgList *getArgListNext(af_ArgList *al);
-
-#endif //AFUN_FUNC

include/core/gc.hpp

@@ -1,34 +0,0 @@
-#ifndef AFUN_GC
-#define AFUN_GC
-#include "aFunCoreExport.h"
-#include "object.hpp"
-#include "var.hpp"
-
-typedef uint32_t GcCount;
-typedef struct af_GcList af_GcList;
-enum af_GcListType {
-    glt_obj = 1,
-    glt_vs,
-    glt_var,
-    glt_vsl,
-};
-
-/* GcList 创建与释放 */
-AFUN_CORE_EXPORT af_GcList *makeGcList(enum af_GcListType type, void *data);
-AFUN_CORE_EXPORT void freeAllGcList(af_GcList *gl);
-
-/* GcList 相关操作 */
-AFUN_CORE_EXPORT af_GcList *pushGcList(enum af_GcListType type, void *data, af_GcList *base);
-
-/* gc Reference 相关操作 */
-AFUN_CORE_EXPORT void gc_addObjectReference(af_Object *obj, af_Environment *base);
-AFUN_CORE_EXPORT void gc_addVarReference(af_Var *obj, af_Environment *base);
-AFUN_CORE_EXPORT void gc_addVarSpaceReference(af_VarSpace *obj, af_Environment *base);
-AFUN_CORE_EXPORT void gc_delObjectReference(af_Object *obj, af_Environment *base);
-AFUN_CORE_EXPORT void gc_delVarReference(af_Var *obj, af_Environment *base);
-AFUN_CORE_EXPORT void gc_delVarSpaceReference(af_VarSpace *obj, af_Environment *base);
-AFUN_CORE_EXPORT void gc_delVarListReference(af_VarList *vsl, af_Environment *base);
-
-/* gc 操控函数 : gc的启动由解释器完全管理 */
-AFUN_CORE_EXPORT af_GuardianList *gc_RunGC(af_Environment *env);
-#endif //AFUN_GC

include/core/global_obj.hpp

@@ -1,7 +0,0 @@
-#ifndef AFUN_GLOBAL_OBJ_HPP
-#define AFUN_GLOBAL_OBJ_HPP
-#include "env.hpp"
-#include "object.hpp"
-
-AFUN_CORE_EXPORT af_Object *makeGlobalObject(af_Environment *env);
-#endif //AFUN_GLOBAL_OBJ_HPP

include/core/info/obj_api.h

@@ -1,74 +0,0 @@
-/*
- * 文件名: obj_api.h
- * 目标:
- * 1) 定义一些函数签名
- * 2) 定义Object的函数签名
- *
- * 注意: 该文件不包含在object.h中, object.h并不依赖该文件
- */
-
-#ifndef AFUN_OBJ_API_H
-#define AFUN_OBJ_API_H
-#include <iostream>
-#include "env.hpp"
-#include "object.hpp"
-#include "var.hpp"
-#include "func.hpp"
-#include "gc.hpp"
-
-/* 定义一些函数原型 */
-/* API函数 */
-typedef void objectAPIFunc();  // 位于object.h (所有Object API函数指针都转换为该类型存储, 注: 具体调用类型参见下文)
-
-/* 顶层信号处理器函数 */
-typedef void TopMsgProcessFunc(af_Message *msg, bool is_top, af_Environment *env);  // 位于env.h
-
-/* 守护器处理函数 */
-typedef af_GuardianList *GuardianFunc(const char *type, bool is_guard, void *data, af_Environment *env);
-typedef void GuardianDestruct(const char *type, void *data, af_Environment *env);
-
-/* 回调C函数 */
-typedef struct af_CallFuncInfo af_CallFuncInfo;
-typedef struct af_FuncBody *callFuncBody(af_CallFuncInfo *info, af_Environment *env);  // 位于env.h
-
-/* 定义Object的函数签名 */
-/*
- * API的第一个参数必须为: id
- * API第二个参数通常为: object
- * API第三个参数: 通常为void *data [仅与data有关的函数会直接传入该值]
- */
-
-#define BASE_ARG const std::string &id, af_Object *obj /* 基础参数 */
-
-/*** Object void *data 管理 ***/
-typedef size_t obj_getDataSize(BASE_ARG);  // 获取data的大小
-typedef void obj_initData(BASE_ARG, void *data, af_Environment *env);  // 初始化data
-typedef void obj_destructData(BASE_ARG, void *data, af_Environment *env);  // 释放data的内容 (但不释放void *data)指针
-
-/*** Object 面向对象管理 ***/
-typedef af_VarSpace *obj_getShareVarSpace(BASE_ARG);
-
-/*** Object 函数调用 ***/
-/* 获取参数计算表 */
-typedef bool obj_funcGetArgCodeList(BASE_ARG, af_ArgCodeList **acl, af_Code *code, void **mark, af_Environment *env);
-/* 获取函数变量空间 */
-typedef bool obj_funcGetVarList(BASE_ARG, af_VarList **vsl, void *mark, af_Environment *env);
-/* 获取参数赋值表 */
-typedef bool obj_funcGetArgList(BASE_ARG, af_ArgList **al, af_ArgCodeList *acl, void *mark, af_Environment *env);
-/* 获取函数信息 */
-typedef bool obj_funcGetInfo(BASE_ARG, af_FuncInfo **fi, af_Code *code, void *mark, af_Environment *env);
-/* 释放mask的函数 */
-typedef void obj_funcFreeMask(BASE_ARG, void *mark);
-
-/*** Object 字面量设定 ***/
-typedef void obj_literalSetting(BASE_ARG, void *data, char *str, af_Environment *env);
-
-/*** Object 函数管理 ***/
-typedef bool obj_isObjFunc(BASE_ARG);  // 是否对象函数
-typedef bool obj_isInfixFunc(BASE_ARG);  // 是否中缀函数
-
-/*** Object gc管理 ***/
-typedef af_GcList *obj_getGcList(BASE_ARG, void *data);  // 是否对象函数
-
-#undef BASE_ARG
-#endif //AFUN_OBJ_API_H

include/core/object.hpp

@@ -1,64 +0,0 @@
-#ifndef AFUN_OBJECT
-#define AFUN_OBJECT
-#include <iostream>
-#include "aFunCoreExport.h"
-#include "tool.hpp"
-
-typedef uint32_t ObjAPIUint;
-typedef struct af_Object af_Object;
-typedef struct af_Inherit af_Inherit;
-typedef struct af_ObjectAPI af_ObjectAPI;
-
-/* 对象API函数 DLC */
-typedef void objectAPIFunc();
-DEFINE_DLC_SYMBOL(objectAPIFunc);
-
-#include "env.hpp"
-#include "var.hpp"
-
-/* 对象创建 */
-AFUN_CORE_EXPORT af_Object * makeObject(const std::string &id, bool free_api, af_ObjectAPI *api, bool allow_inherit,
-                                        af_Object *belong, bool free_inherit, af_Inherit *inherit,
-                                        af_Environment *env);
-
-/* API表 创建与释放 */
-AFUN_CORE_EXPORT af_ObjectAPI *makeObjectAPI();
-AFUN_CORE_EXPORT void freeObjectAPI(af_ObjectAPI *api);
-
-/* 对象继承表 创建与释放 */
-AFUN_CORE_EXPORT af_Inherit *makeInherit(af_Object *obj);
-AFUN_CORE_EXPORT void freeAllInherit(af_Inherit *ih);
-
-/* 对象 相关操作 */
-AFUN_CORE_EXPORT bool setObjectAttributes(const char *name, char p_self, char p_posterity, char p_external, af_Object *attributes,
-                                          af_Object *obj, af_Object *visitor, af_Environment *env);
-AFUN_CORE_EXPORT void objectSetAllowInherit(af_Object *obj, bool allow);
-
-/* API表 相关操作 */
-AFUN_CORE_EXPORT int addAPI(DLC_SYMBOL(objectAPIFunc) func, const char *api_name, af_ObjectAPI *api);
-AFUN_CORE_EXPORT int addAPIToObject(DLC_SYMBOL(objectAPIFunc) func, const char *api_name, af_Object *obj);
-
-/* 对象继承表 相关操作 */
-AFUN_CORE_EXPORT af_Inherit **pushInherit(af_Inherit **base, af_Inherit *new_ih);
-
-/* 对象 属性访问 */
-AFUN_CORE_EXPORT void *getObjectData(af_Object *obj);
-AFUN_CORE_EXPORT af_Object *getBelongObject(af_Object *object);
-AFUN_CORE_EXPORT af_Object *findObjectAttributes(char *name, af_Object *visitor, af_Object *obj, af_Environment *env);
-AFUN_CORE_EXPORT const std::string &getObjectID(af_Object *obj);
-AFUN_CORE_EXPORT af_ObjectAPI *getObjectAPI(af_Object *obj);
-AFUN_CORE_EXPORT af_Inherit *getObjectInherit(af_Object *obj);
-AFUN_CORE_EXPORT af_VarSpace *getObjectVarSpace(af_Object *obj);
-AFUN_CORE_EXPORT bool isObjectAllowInherit(af_Object *obj);
-
-/* API表 属性访问 */
-AFUN_CORE_EXPORT objectAPIFunc *findAPI(const char *api_name, af_ObjectAPI *api);
-AFUN_CORE_EXPORT objectAPIFunc *findObjectAPI(const char *api_name, af_Object *obj);
-AFUN_CORE_EXPORT ObjAPIUint getAPICount(af_ObjectAPI *api);
-
-/* 对象继承表 属性访问 */
-AFUN_CORE_EXPORT bool checkPosterity(af_Object *base, af_Object *posterity);
-AFUN_CORE_EXPORT af_Inherit *getInheritNext(af_Inherit *ih);
-AFUN_CORE_EXPORT af_Object *getInheritObject(af_Inherit *ih);
-AFUN_CORE_EXPORT af_VarSpace *getInheritVarSpace(af_Inherit *ih);
-#endif //AFUN_OBJECT

include/core/parser.hpp

@@ -1,26 +0,0 @@
-#ifndef AFUN_PARSER_HPP
-#define AFUN_PARSER_HPP
-#include "aFunCoreExport.h"
-#include "tool.hpp"
-#include "token.h"
-#include "reader.hpp"
-
-#define SYNTACTIC_MAX_DEEP (1000)
-typedef struct af_Parser af_Parser;
-
-#define STDIN_MAX_SIZE (1024)
-
-/* Parser 创建与释放 */
-AFUN_CORE_EXPORT af_Parser *makeParser(FilePath file,
-                                       DLC_SYMBOL(readerFunc) read_func, DLC_SYMBOL(destructReaderFunc) destruct_func,
-                                       size_t data_size);
-AFUN_CORE_EXPORT void freeParser(af_Parser *parser);
-AFUN_CORE_EXPORT af_Parser *makeParserByString(ConstFilePath name, const char *str, bool free_str);
-AFUN_CORE_EXPORT af_Parser *makeParserByFile(ConstFilePath path);
-AFUN_CORE_EXPORT af_Parser *makeParserByStdin(ConstFilePath file);
-
-/* Parser 相关操作 */
-AFUN_CORE_EXPORT af_Code *parserCode(af_Parser *parser);
-AFUN_CORE_EXPORT void initParser(af_Parser *parser);
-
-#endif //AFUN_PARSER_HPP

include/core/reader.hpp

@@ -1,15 +0,0 @@
-#ifndef AFUN_READER_HPP
-#define AFUN_READER_HPP
-#include "tool.hpp"
-
-#define READER_MODE_NORMAL (0)
-#define READER_MODE_FINISHED (1)
-#define READER_MODE_ERROR (2)
-
-typedef size_t readerFunc(void *data, char *dest, size_t len, int *mde);
-DEFINE_DLC_SYMBOL(readerFunc);
-
-typedef void destructReaderFunc(void *data);
-DEFINE_DLC_SYMBOL(destructReaderFunc);
-
-#endif //AFUN_READER_HPP

include/core/run.hpp

@@ -1,8 +0,0 @@
-#ifndef AFUN_RUN_HPP
-#define AFUN_RUN_HPP
-#include "aFunCoreExport.h"
-#include "tool.hpp"
-#include "code.hpp"
-/* 代码运行 相关操作 */
-AFUN_CORE_EXPORT bool iterCode(af_Code *code, int mode, af_Environment *env);
-#endif //AFUN_RUN_HPP

include/core/sig.hpp

@@ -1,10 +0,0 @@
-#ifndef AFUN_SIG_HPP
-#define AFUN_SIG_HPP
-#include <signal.h>
-#include "aFunCoreExport.h"
-
-AFUN_CORE_EXPORT void aFunSignalInit(void);
-AFUN_CORE_EXPORT void aFunSignalRecover(void);
-AFUN_CORE_EXPORT bool aFunGetSignal(int signum);
-
-#endif //AFUN_SIG_HPP

include/core/thread.hpp

@@ -1,9 +0,0 @@
-#ifndef AFUN_THREAD_HPP
-#define AFUN_THREAD_HPP
-
-AFUN_CORE_EXPORT af_Environment *
-startRunThread(af_Environment *env, af_VarSpace *vs, af_Code *code, bool not_copy_code, bool derive_tmp,
-               bool derive_guardian, bool derive_lr, bool enable);
-AFUN_CORE_EXPORT void startRunThread_(af_Environment *env, af_Code *code, bool not_copy_code);
-
-#endif //AFUN_THREAD_HPP

include/core/var.hpp

@@ -1,67 +0,0 @@
-#ifndef AFUN_VAR
-#define AFUN_VAR
-
-typedef struct af_Var af_Var;
-typedef struct af_VarSpace af_VarSpace;
-typedef struct af_VarList af_VarList;
-
-#include "aFunCoreExport.h"
-#include "tool.hpp"
-#include "object.hpp"
-
-/* 变量 创建 */
-AFUN_CORE_EXPORT af_Var *makeVar(const char *name,
-                                 char p_self, char p_posterity, char p_external,
-                                 af_Object *obj, af_Environment *env);
-
-/* 变量空间 创建 */
-AFUN_CORE_EXPORT af_VarSpace *makeVarSpace(af_Object *belong, char p_self, char p_posterity, char p_external, af_Environment *env);
-
-/* 变量空间链 创建与释放 */
-AFUN_CORE_EXPORT af_VarList *makeVarSpaceList(af_VarSpace *vs);
-AFUN_CORE_EXPORT af_VarList *copyVarSpaceList(af_VarList *vsl);
-AFUN_CORE_EXPORT void freeAllVarSpaceList(af_VarList *vsl);
-AFUN_CORE_EXPORT bool freeVarSpaceListCount(size_t count, af_VarList *vsl);
-
-/* 变量 相关操作 */
-AFUN_CORE_EXPORT void addVarNode(af_Var *var, af_Object *obj, const char *id);
-
-/* 变量空间 相关操作 */
-AFUN_CORE_EXPORT bool addVarToVarSpace(af_Var *var, af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-AFUN_CORE_EXPORT bool makeVarToVarSpace(const char *name,
-                                        char p_self, char p_posterity, char p_external,
-                                        af_Object *obj, af_VarSpace *vs, af_Object *visitor, af_Environment *env);
-AFUN_CORE_EXPORT bool delVarFromVarSpace(const char *name, af_Object *visitor, af_VarSpace *vs);
-AFUN_CORE_EXPORT bool setVarToVarSpace(const char *name, af_Object *obj, af_Object *visitor, af_VarSpace *vs);
-AFUN_CORE_EXPORT void setVarPermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs, char p_self, char p_posterity, char p_external);
-AFUN_CORE_EXPORT void setVarSpacePermissions(af_Object *visitor, af_VarSpace *vs, char p_self, char p_posterity, char p_external);
-AFUN_CORE_EXPORT bool setVarSpaceProtect(af_Object *visitor, af_VarSpace *vs, bool protect);
-
-/* 变量空间链 相关操作 */
-AFUN_CORE_EXPORT bool addVarToVarSpaceList(af_Var *var, af_Object *visitor, af_VarList *vsl,
-                                           af_Environment *env);
-AFUN_CORE_EXPORT bool makeVarToVarSpaceList(const char *name,
-                                            char p_self, char p_posterity, char p_external,
-                                            af_Object *obj, af_VarList *vsl, af_Object *visitor, af_Environment *env);
-AFUN_CORE_EXPORT bool makeVarToProtectVarSpace(const char *name,
-                                               char p_self, char p_posterity, char p_external,
-                                               af_Object *obj, af_Environment *env);
-AFUN_CORE_EXPORT bool addVarToProtectVarSpace(af_Var *var, af_Environment *env);
-AFUN_CORE_EXPORT bool delVarFromVarList(const char *name,af_Object *visitor, af_VarList *vsl);
-AFUN_CORE_EXPORT bool setVarToVarList(const char *name, af_Object *obj, af_Object *visitor, af_VarList *vsl);
-AFUN_CORE_EXPORT af_VarList *pushNewVarList(af_Object *belong, af_VarList *base, af_Environment *env);
-AFUN_CORE_EXPORT af_VarList *pushProtectVarList(af_VarList *base, af_Environment *env);
-AFUN_CORE_EXPORT af_VarList *pushVarList(af_VarSpace *vs, af_VarList *base);
-
-/* 变量 属性访问 */
-AFUN_CORE_EXPORT af_Object *findVarNode(af_Var *var, const char *id, af_Environment *env);
-
-/* 变量空间 属性访问 */
-AFUN_CORE_EXPORT af_Var *findVarFromVarSpace(const char *name, af_Object *visitor, af_VarSpace *vs);
-AFUN_CORE_EXPORT bool isProtectVarSpace(af_VarSpace *vs);
-
-/* 变量空间链 属性访问 */
-AFUN_CORE_EXPORT af_Var *findVarFromVarList(const char *name, af_Object *visitor, af_VarList *vsl);
-AFUN_CORE_EXPORT af_VarSpace *getVarSpaceFromList(af_VarList *vsl);
-
-#endif //AFUN_VAR

include/main.hpp

@@ -1,16 +0,0 @@
-#ifndef AFUN_MAIN_HPP
-#define AFUN_MAIN_HPP
-#include "base.h"
-
-#ifdef aFunWIN32_NO_CYGWIN
-#include <io.h>
-#define fileno _fileno
-#define isatty _isatty
-#else
-#include "unistd.h"
-#endif
-
-extern char *base_path;
-extern Logger *aFunlangLogger;
-
-#endif //AFUN_MAIN_HPP

include/runtime/aFunlang.hpp

@@ -1,38 +0,0 @@
-#ifndef AFUN_AFUNLANG_HPP
-#define AFUN_AFUNLANG_HPP
-#include "aFunlangExport.h"
-#include "aFunCore.hpp"
-#include "runtime.hpp"
-
-typedef struct aFunInitInfo aFunInitInfo;
-struct aFunInitInfo {
-    const char *base_dir;
-
-    bool log_asyn;
-    jmp_buf *buf;
-    LogLevel level;
-};
-
-typedef struct aFunRunInfo aFunRunInfo;
-struct aFunRunInfo {
-    bool signal;
-};
-
-AFUN_LANG_EXPORT bool aFunInit(aFunInitInfo *info);
-AFUN_LANG_EXPORT bool aFunDestruct();
-
-AFUN_LANG_EXPORT void defineRunEnv(aFunRunInfo *run_env);
-AFUN_LANG_EXPORT void undefRunEnv(aFunRunInfo *run_env);
-
-AFUN_LANG_EXPORT af_Environment *creatAFunEnvironment(int argc, char **argv);
-AFUN_LANG_EXPORT bool destructAFunEnvironment(af_Environment *env);
-
-/* 源文件运行 */
-AFUN_LANG_EXPORT int runCodeFromString(const char *code, const char *string_name, int mode, af_Environment *env);
-AFUN_LANG_EXPORT int runCodeFromFileSource(FilePath file, bool save_afb, FilePath save_path, int mode, af_Environment *env);
-AFUN_LANG_EXPORT int runCodeFromStdin(const char *name, af_Environment *env);
-AFUN_LANG_EXPORT int runCodeFromMemory(af_Code *code, int mode, af_Environment *env);
-AFUN_LANG_EXPORT int runCodeFromFileByte(FilePath file, int mode, af_Environment *env);
-AFUN_LANG_EXPORT int runCodeFromFile(FilePath file, bool save_afb, int mode, af_Environment *env);
-AFUN_LANG_EXPORT int buildFile(FilePath out, FilePath in);
-#endif //AFUN_AFUNLANG_HPP

include/runtime/runtime.hpp

@@ -1,83 +0,0 @@
-#ifndef AFUN_RUNTIME_HPP
-#define AFUN_RUNTIME_HPP
-#include <iostream>
-
-typedef struct APIFuncList APIFuncList;
-struct APIFuncList {
-    const char *name;
-    void *func;  // objectAPIFunc
-    DlcHandle *dlc;  // func 的 来源
-    DLC_SYMBOL(objectAPIFunc) func_;  // func_和func二选一, func_时dlc无效
-    bool free_func_;  // func_是否需要释放
-};
-
-typedef struct InheritDefineList InheritDefineList;
-struct InheritDefineList {
-    af_Object *obj;
-};
-
-typedef struct ObjectDefineList ObjectDefineList;
-struct ObjectDefineList {
-    const std::string &id;
-
-    bool free_api;
-    af_ObjectAPI *api;
-    struct APIFuncList *api_list;  // api和api_list只能二选一
-
-    bool allow_inherit;
-    af_Object *belong;
-    af_Inherit *inherit;
-
-    const char *var_name;
-    char p_self, p_posterity, p_external;
-
-    af_Object **save;  // obj保存位置
-};
-
-typedef struct LiteralFuncList LiteralFuncList;
-struct LiteralFuncList {
-    const char *pattern;
-    const char *func;
-    bool in_protect;
-};
-
-typedef struct TopMsgFuncList TopMsgFuncList;
-struct TopMsgFuncList {
-    const char *type;
-    TopMsgProcessFunc *func;
-    DlcHandle *dlc;  // func 的 来源
-    DLC_SYMBOL(TopMsgProcessFunc) func_;  // func_和func二选一, func_时dlc无效
-    bool free_func_;  // func_是否需要释放
-};
-
-typedef struct GuardianFuncList GuardianFuncList;
-struct GuardianFuncList {
-    const char *type;
-    bool always;
-    bool derive;
-    size_t size;
-
-    DlcHandle *dlc;  // func/destruct 的 来源
-    GuardianFunc *func;
-    DLC_SYMBOL(GuardianFunc) func_;
-    bool free_func_;  // func_是否需要释放
-
-    GuardianDestruct *destruct;
-    DLC_SYMBOL(GuardianDestruct) destruct_;
-    bool free_destruct_;  // func_是否需要释放
-
-    void **data;
-    void (*initData)(void *data, af_Environment *env);  // data初始化的函数
-};
-
-AFUN_LANG_EXPORT int runtimeTool(const char *name, af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-AFUN_LANG_EXPORT int runtimeToolImport(const char *name, af_Object **obj, af_Code **code, af_Environment *env);
-
-AFUN_LANG_EXPORT af_ObjectAPI *makeAPIFromList(const APIFuncList api_list[]);
-AFUN_LANG_EXPORT void makeObjectFromList(const ObjectDefineList obj_def[], af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-AFUN_LANG_EXPORT void makeLiteralRegexFromList(const LiteralFuncList literal_list[], af_Environment *env);
-AFUN_LANG_EXPORT void makeTopMsgProcessFromList(const TopMsgFuncList top_msg_list[], af_Environment *env);
-AFUN_LANG_EXPORT af_Inherit *makeInheritFromList(const InheritDefineList inherit_list[], bool is_reverse);
-AFUN_LANG_EXPORT void makeGuardianFromList(const GuardianFuncList gd_list[], af_Environment *env);
-
-#endif //AFUN_RUNTIME_HPP

include/tool/btye.hpp

@@ -1,37 +1,31 @@
 #ifndef AFUN_BYTE_H
 #define AFUN_BYTE_H
-#include <stdio.h>
+#include <cstdio>  // NOLINT
+#include <iostream>
 #include "aFunToolExport.h"
 
-// byte工具
-#define byteWriteInt_8(file, s) (byteWriteUint_8(file, ((uint8_t)(s))))
-#define byteWriteInt_16(file, s) (byteWriteUint_16(file, ((uint16_t)(s))))
-#define byteWriteInt_32(file, s) (byteWriteUint_32(file, ((uint32_t)(s))))
-#define byteWriteInt_64(file, s) (byteWriteUint_64(file, ((uint64_t)(s))))
-
-#define byteReadInt_8(file, s) (byteReadUint_8(file, ((uint8_t *)(s))))
-#define byteReadInt_16(file, s) (byteReadUint_16(file, ((uint16_t *)(s))))
-#define byteReadInt_32(file, s) (byteReadUint_32(file, ((uint32_t *)(s))))
-#define byteReadInt_64(file, s) (byteReadUint_64(file, ((uint64_t *)(s))))
-
-enum af_EndianType{
-    little_endian = 0,
-    big_endian
-};
-
-extern enum af_EndianType endian;
-
-AFUN_TOOL_EXPORT void getEndian();
-AFUN_TOOL_EXPORT bool byteWriteUint_8(FILE *file, uint8_t ch);
-AFUN_TOOL_EXPORT bool byteWriteUint_16(FILE *file, uint16_t num);
-AFUN_TOOL_EXPORT bool byteWriteUint_32(FILE *file, uint32_t num);
-AFUN_TOOL_EXPORT bool byteWriteUint_64(FILE *file, uint64_t num);
-AFUN_TOOL_EXPORT bool byteWriteStr(FILE *file, const char *str);
-
-AFUN_TOOL_EXPORT bool byteReadUint_8(FILE *file, uint8_t *ch);
-AFUN_TOOL_EXPORT bool byteReadUint_16(FILE *file, uint16_t *num);
-AFUN_TOOL_EXPORT bool byteReadUint_32(FILE *file, uint32_t *num);
-AFUN_TOOL_EXPORT bool byteReadUint_64(FILE *file, uint64_t *num);
-AFUN_TOOL_EXPORT bool byteReadStr(FILE *file, char **str);
+namespace aFuntool {
+    enum af_EndianType {
+        little_endian = 0,
+        big_endian
+    };
+
+    extern enum af_EndianType endian;
+
+    AFUN_TOOL_EXPORT void getEndian();
+
+    template <typename T>
+    AFUN_TOOL_EXPORT bool byteWriteInt(FILE *file, T num);;
+
+    AFUN_TOOL_EXPORT bool byteWriteStr(FILE *file, const char *str);
+    AFUN_TOOL_EXPORT bool byteWriteStr(FILE *file, const std::string &str);
+
+    template <typename T>
+    AFUN_TOOL_EXPORT bool byteReadInt(FILE *file, T *num);
+
+    AFUN_TOOL_EXPORT bool byteReadStr(FILE *file, std::string &str);
+    AFUN_TOOL_EXPORT bool byteReadStr(FILE *file, char *&str);
+
+}
 
 #endif //AFUN_BYTE_H

include/tool/dlc.hpp

@@ -1,8 +1,10 @@
 #ifndef AFUN_DLC_HPP
 #define AFUN_DLC_HPP
+#include <iostream>
 #include "aFunToolExport.h"
 #include "dlfcn.h"  // CMake 处理 dlfcn.h 的位置
 
+
 /* 动态库工具(dlc): 处理动态库的使用 */
 
 /*
@@ -19,28 +21,97 @@
  * dlcExit: 释放所有动态库
  */
 
-#define DEFINE_DLC_SYMBOL(NAME) typedef struct DLC##NAME##SYMBOL *pDLC##NAME##SYMBOL
-#define NEW_DLC_SYMBOL(TYPE, NAME) typedef struct DLC##NAME##SYMBOL { TYPE *symbol; struct DlcHandle *dlc; } DLC##NAME##SYMBOL, *pDLC##NAME##SYMBOL
+namespace aFuntool {
+    class DlcHandle;
+
+    template <typename SYMBOL>
+    class DlcSymbol;
+
+    AFUN_TOOL_EXPORT DlcHandle *openLibrary(const char *file, int mode);
+    AFUN_TOOL_EXPORT void dlcExit();
+
+    /**
+     * DlcHandle: 动态库句柄
+     * 注意: 仅能通过 openLibrary生成
+     * 不需要 delete 释放 (自动管理释放)
+     */
+    class DlcHandle {
+        friend void dlcExit();
+        friend DlcHandle *openLibrary(const char *file, int mode);
+
+        explicit DlcHandle(void *handle);  // 仅 openLibary 可用
+        void *handle;
+        int link;  // 引用计数
+        struct DlcHandle *next;
+        struct DlcHandle *prev;
+    public:
+        ~DlcHandle();
+
+        /**
+         * 获得动态库中指定名字的符号
+         * @tparam SYMBOL 符号类型
+         * @param name 名字
+         * @return 符号
+         */
+        template<typename SYMBOL>
+        DlcSymbol<SYMBOL> *get_symbol(const std::string &name) {
+            auto symbol = (SYMBOL *)dlsym(handle, name.c_str());
+            if (symbol == nullptr)
+                return nullptr;
+            return new DlcSymbol<SYMBOL>(symbol, this);
+        }
+
+        /**
+         * 关闭动态库句柄
+         */
+        void close();
+        int operator++(int);
+        int operator--(int);
+    };
 
-typedef struct DlcSymbol_ DlcSymbol_;
-typedef struct DlcHandle DlcHandle;
+    /**
+     * 符号句柄
+     * 注意: 不适用符号后需要 delete
+     * @tparam SYMBOL 符号类型
+     */
+    template <typename SYMBOL>
+    class DlcSymbol {
+        SYMBOL *symbol;
+        class DlcHandle *dlc = nullptr;
 
-#define DLC_SYMBOL(NAME) pDLC##NAME##SYMBOL
-#define GET_SYMBOL(SYMBOL) (*((SYMBOL)->symbol))
-#define MAKE_SYMBOL(symbol, TYPE) ((pDLC##TYPE##SYMBOL) (makeSymbol_(nullptr, (DlcSymbol_ *)(symbol))))
-#define MAKE_SYMBOL_FROM_HANDLE(symbol, handle, TYPE) ((pDLC##TYPE##SYMBOL) (makeSymbol_((handle), (DlcSymbol_ *)(symbol))))
-#define COPY_SYMBOL(ds, TYPE) ((pDLC##TYPE##SYMBOL) (copySymbol_((DlcSymbol_ *)(ds))))
-#define READ_SYMBOL(dlc, name, TYPE) ((pDLC##TYPE##SYMBOL) (getSymbol_((dlc), (name))))
-#define FREE_SYMBOL(symbol) ((symbol) != nullptr ? (freeSymbol_((DlcSymbol_ *)(symbol)), nullptr) : nullptr)
+    public:
+        /**
+         * 从句柄和符号指针创建一个符号
+         * @param symbol 符号指针
+         * @param dlc 句柄
+         */
+        explicit DlcSymbol(SYMBOL *symbol, class DlcHandle *dlc) {
+            this->symbol = symbol;
+            this->dlc = dlc;
+            if (this->dlc != nullptr)
+                this->dlc++;
+        }
 
-AFUN_TOOL_EXPORT DlcHandle *openLibary(const char *file, int mode);
-AFUN_TOOL_EXPORT DlcSymbol_ *makeSymbol_(DlcHandle *dlc, void *symbol);
-AFUN_TOOL_EXPORT DlcSymbol_ *copySymbol_(DlcSymbol_ *ds);
-AFUN_TOOL_EXPORT DlcSymbol_ *getSymbol_(DlcHandle *dlc, const char *name);
+        /**
+         * 复制符号
+         * @param symbol
+         */
+        explicit DlcSymbol(class DlcSymbol<SYMBOL> *symbol) {
+            this->symbol = symbol->symbol;
+            this->dlc = symbol->dlc;
+            if (this->dlc != nullptr)
+                this->dlc++;
+        }
 
-AFUN_TOOL_EXPORT void freeSymbol_(DlcSymbol_ *symbol);
-AFUN_TOOL_EXPORT bool freeLibary(DlcHandle *dlc);
-AFUN_TOOL_EXPORT void dlcExit();
+        ~DlcSymbol(){
+            if (dlc != nullptr)
+                dlc--;
+        }
 
+        SYMBOL *getSymbol() const {
+            return symbol;
+        }
+    };
+}
 
 #endif //AFUN_DLC_HPP

include/tool/exit_.hpp

@@ -1,16 +1,14 @@
 #ifndef AFUN_EXIT_H
 #define AFUN_EXIT_H
-#include <cstdlib>
 
-typedef void aFunExitFunc(void *);
+namespace aFuntool {
+    typedef void aFunExitFunc(void *);
 
-#define aFunExitSuccess EXIT_SUCCESS
-#define aFunExitFail EXIT_FAILURE
-
-[[ noreturn ]] AFUN_TOOL_EXPORT void aFunExit(int exit_code);
-AFUN_TOOL_EXPORT int aFunTryExitPseudo();
-AFUN_TOOL_EXPORT int aFunExitPseudo();
-AFUN_TOOL_EXPORT int aFunAtExitTry(aFunExitFunc *func, void *data);
-AFUN_TOOL_EXPORT int aFunAtExit(aFunExitFunc *func, void *data);
+    [[noreturn]] AFUN_TOOL_EXPORT void aFunExit(int exit_code);
+    AFUN_TOOL_EXPORT int aFunTryExitPseudo();
+    AFUN_TOOL_EXPORT int aFunExitPseudo();
+    AFUN_TOOL_EXPORT int aFunAtExitTry(aFunExitFunc *func, void *data);
+    AFUN_TOOL_EXPORT int aFunAtExit(aFunExitFunc *func, void *data);
+}
 
 #endif //AFUN_EXIT_H

include/tool/file.hpp

@@ -3,18 +3,26 @@
 #include "aFunToolExport.h"
 
 /* 文件处理工具 */
-AFUN_TOOL_EXPORT int checkFile(const char *path);
-AFUN_TOOL_EXPORT time_t getFileMTime(const char *path);
-AFUN_TOOL_EXPORT char *joinPath(const char *path, const char *name, const char *suffix);
-AFUN_TOOL_EXPORT char *getFileName(const char *path_1);
-AFUN_TOOL_EXPORT char *getFileNameWithPath(const char *path_1);
-AFUN_TOOL_EXPORT char *getFilePath(const char *path_1, int dep);
-AFUN_TOOL_EXPORT char *getFileSurfix(const char *path);
-AFUN_TOOL_EXPORT char *fileNameToVar(char *name, bool need_free);
-AFUN_TOOL_EXPORT char *findPath(char *path, const char *env, bool need_free);
-AFUN_TOOL_EXPORT char *getExedir(int dep);
-AFUN_TOOL_EXPORT uintmax_t getFileSize(const char *path);
-AFUN_TOOL_EXPORT bool isCharUTF8(const char *str);
-AFUN_TOOL_EXPORT FILE *fileOpen(const char *path_, const char *mode_);
-AFUN_TOOL_EXPORT int fileClose(FILE *file);
+namespace aFuntool {
+    class FileOpenException : public std::exception {
+        virtual const char *what() {return "File cannot open";}
+    };
+
+    AFUN_TOOL_EXPORT int checkFile(const std::string &path);
+    AFUN_TOOL_EXPORT time_t getFileMTime(const std::string &path);
+    AFUN_TOOL_EXPORT std::string joinPath(const std::string &path, const std::string &name, const std::string &suffix);
+    AFUN_TOOL_EXPORT std::string getFileName(const std::string &path);
+    AFUN_TOOL_EXPORT std::string getFilePathName(const std::string &path);
+    AFUN_TOOL_EXPORT std::string getFilePath(const std::string &path_1, int dep);
+    AFUN_TOOL_EXPORT std::string getFileSurfix(const std::string &path);
+    AFUN_TOOL_EXPORT std::string fileNameToVar(const std::string &name);
+    AFUN_TOOL_EXPORT std::string findPath(const std::string &path, const std::string &env);
+    AFUN_TOOL_EXPORT std::string getExedir(int dep);
+    AFUN_TOOL_EXPORT uintmax_t getFileSize(const std::string &path);
+    AFUN_TOOL_EXPORT bool isCharUTF8(const char *str);
+    AFUN_TOOL_EXPORT bool isCharUTF8(const std::string &str);
+    AFUN_TOOL_EXPORT FILE *fileOpen(const std::string &path_, const char *mode_);
+    AFUN_TOOL_EXPORT FILE *fileOpen(const char *path_, const char *mode_);
+    AFUN_TOOL_EXPORT int fileClose(FILE *file);
+}
 #endif //AFUN_FILE_HPP

include/tool/hash.hpp

@@ -3,8 +3,10 @@
 #include "aFunToolExport.h"
 
 /* 哈希工具 */
-typedef long int time33_t;
-
-AFUN_TOOL_EXPORT time33_t time33(const char *str);
+namespace aFuntool {
+    typedef long int time33_t;
+    AFUN_TOOL_EXPORT time33_t time33(const char *str);
+    AFUN_TOOL_EXPORT time33_t time33(const std::string &str);
+}
 
 #endif //AFUN_HASH_HPP

include/tool/log.hpp

@@ -1,119 +1,162 @@
 #ifndef AFUN_LOG_HPP
 #define AFUN_LOG_HPP
-#include <csetjmp>
+#include <iostream>
 #include "aFunToolExport.h"
 #include "macro.hpp"
-#include "log_macro.hpp"
-
-enum LogLevel {
-    log_track = 0,
-    log_debug = 1,
-    log_info = 2,
-    log_warning = 3,
-    log_error = 4,
-    log_send_error = 5,
-    log_fatal_error = 6,
-};
-typedef enum LogLevel LogLevel;
-
-enum LogFactoryPrintConsole {
-    log_pc_all = 1,
-    log_pc_w = 2,
-    log_pc_e = 3,
-    log_pc_quite = 4,
-};
-typedef enum LogFactoryPrintConsole LogFactoryPrintConsole;
-
-struct Logger {
-    const char *id;
-    LogLevel level;
-    jmp_buf *buf;
-};
-typedef struct Logger Logger;
-
-AFUN_TOOL_EXPORT void printLogSystemInfo();
-AFUN_TOOL_EXPORT int initLogSystem(FilePath path, bool asyn);
-AFUN_TOOL_EXPORT int destructLogSystem();
-
-AFUN_TOOL_EXPORT void initLogger(Logger *logger, const char *id, LogLevel level);
-AFUN_TOOL_EXPORT void destructLogger(Logger *logger);
-
-AFUN_TOOL_EXPORT int writeTrackLog_(Logger *logger,
-                                    const char *file, int line, const char *func,
-                                    const char *format, ...);
-AFUN_TOOL_EXPORT int writeDebugLog_(Logger *logger,
-                                    const char *file, int line, const char *func,
-                                    const char *format, ...);
-AFUN_TOOL_EXPORT int writeInfoLog_(Logger *logger,
-                                   const char *file, int line, const char *func,
-                                   const char *format, ...);
-AFUN_TOOL_EXPORT int writeWarningLog_(Logger *logger,
-                                      const char *file, int line, const char *func,
-                                      const char *format, ...);
-AFUN_TOOL_EXPORT int writeErrorLog_(Logger *logger,
-                                    const char *file, int line, const char *func,
-                                    const char *format, ...);
-AFUN_TOOL_EXPORT int writeSendErrorLog_(Logger *logger,
-                                        const char *file, int line, const char *func,
-                                        const char *format, ...);
-AFUN_TOOL_EXPORT int writeFatalErrorLog_(Logger *logger,
-                                         const char *file, int line, const char *func,
-                                         int exit_code, const char *format, ...);
-
-#ifdef __FILENAME__
-#define file_line (char *)__FILENAME__ , (int)__LINE__
-#else
-#define file_line (char *)"xx", (int)__LINE__
-#endif
+#include "log_m.hpp"
+#include "iostream"
+
+using namespace aFuntool;
+
+namespace aFuntool {
+    enum LogLevel {
+        log_track = 0,
+        log_debug = 1,
+        log_info = 2,
+        log_warning = 3,
+        log_error = 4,
+        log_send_error = 5,
+        log_fatal_error = 6,
+    };
+    typedef enum LogLevel LogLevel;
+
+    class LogFatalError : public std::exception {
+        std::string message;
+    public:
+        explicit LogFatalError(const char *msg) {message = msg;}
+        virtual const char *what() {return message.c_str();}
+    };
+
+    class LogFactory;
+
+    class Logger {
+        std::string id;
+        LogLevel level = log_debug;
+        bool exit = true;
+        friend class LogFactory;
+
+    public:
+        explicit Logger(const std::string &id, LogLevel level=log_warning, bool exit=true);
+        int writeTrackLog(const char *file, int line, const char *func,
+                          const char *format, ...);
+        int writeDebugLog(const char *file, int line, const char *func,
+                          const char *format, ...);
+        int writeInfoLog(const char *file, int line, const char *func,
+                         const char *format, ...);
+        int writeWarningLog(const char *file, int line, const char *func,
+                            const char *format, ...);
+        int writeErrorLog(const char *file, int line, const char *func,
+                          const char *format, ...);
+        int writeSendErrorLog(const char *file, int line, const char *func,
+                              const char *format, ...);
+        int writeFatalErrorLog(const char *file, int line, const char *func,
+                               int exit_code, const char *format, ...);
+    };
+
+
+    class LogFactory {
+        bool init;  // 是否已经初始化
+        pid_t pid;
+
+        FILE *log;  // 记录文件输出的位置
+        FILE *csv;
+
+        bool asyn;  // 异步
+        pthread_t pt;
+        pthread_cond_t cond;  // 有日志
+        pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+        struct LogNode *log_buf;
+        struct LogNode **plog_buf;  // 指向 log_buf的末端
+
+    public:
+        Logger sys_log = Logger("SYSTEM");
+
+        LogFactory();
+        ~LogFactory();
+        int initLogSystem(ConstFilePath path, bool is_asyn=true);
+        bool destruct();
+        void writeLog(LogLevel level,
+                      const char *id, pid_t tid,
+                      const char *ti, time_t t,
+                      const char *file, int line, const char *func,
+                      const char *info);
+        static void writeConsole(LogLevel level,
+                          const char *id, pid_t tid,
+                          const char *ti, time_t t,
+                          const char *file, int line, const char *func,
+                          const char *info);
+        void writeLogAsyn(LogLevel level,
+                          const char *id, pid_t tid,
+                          const char *ti, time_t t,
+                          const char *file, int line, const char *func, const char *info);
+        int newLog(Logger *logger,
+                    bool pc,
+                    LogLevel level,
+                    const char *file, int line, const char *func,
+                    const char *format, va_list ap);
+        bool news() {return !init || log_buf != nullptr;}
+        int wait() {return pthread_cond_wait(&cond, &mutex);}
+        bool stop() {return !init && log_buf == nullptr;}
+        struct LogNode *pop();
+    };
+
+
+    extern LogFactory log_factory;
+}
+
+#ifndef NO_DEFINE_LOG_MACRO
+
+#define getLogger(logger) ((logger) == nullptr ? &aFuntool::log_factory.sys_log : (logger))
 
 #if aFunWriteTrack
-#define writeTrackLog(logger, ...) writeTrackLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
+#define trackLog(logger, ...) getLogger(logger)->writeTrackLog(__FILENAME__ , (int)__LINE__, __FUNCTION__, __VA_ARGS__)
 #else
-#define writeTrackLog(logger, ...) (nullptr)
+#define trackLog(logger, ...) (nullptr)
 #endif
 
 #if aFunWriteDebug
-#define writeDebugLog(logger, ...) writeDebugLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
-#define assertDebugLog(c, logger, ...) ((c) || writeDebugLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#define debugLog(logger, ...) getLogger(logger)->writeDebugLog(__FILENAME__ , (int)__LINE__, __FUNCTION__, __VA_ARGS__)
+#define assertDebugLog(c, logger, ...) ((c) || debugLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeDebugLog(logger, ...) (nullptr)
+#define debugLog(logger, ...) (nullptr)
 #define assertDebugLog(c, logger, ...) (c)
 #endif
 
 #if aFunWriteInfo
-#define writeInfoLog(logger, ...) writeInfoLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
-#define assertInfoLog(c, logger, ...) ((c) || writeInfoLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#define infoLog(logger, ...) getLogger(logger)->writeInfoLog(__FILENAME__ , (int)__LINE__, __FUNCTION__, __VA_ARGS__)
+#define assertInfoLog(c, logger, ...) ((c) || infoLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeInfoLog(logger, ...) (nullptr)
+#define infoLog(logger, ...) (nullptr)
 #define assertInfoLog(c, logger, ...) (c)
 #endif
 
 #if !aFunIgnoreWarning
-#define writeWarningLog(logger, ...) writeWarningLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
-#define assertWarningLog(c, logger, ...) ((c) || writeWarningLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#define warningLog(logger, ...) getLogger(logger)->writeWarningLog(__FILENAME__ , (int)__LINE__, __FUNCTION__, __VA_ARGS__)
+#define assertWarningLog(c, logger, ...) ((c) || warningLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeWarningLog(logger, ...) (nullptr)
+#define warningLog(logger, ...) (nullptr)
 #define assertWarningLog(c, logger, ...) (c)
 #endif
 
 #if !aFunIgnoreError
-#define writeErrorLog(logger, ...) writeErrorLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
-#define assertErrorLog(c, logger, ...) ((c) || writeErrorLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#define errorLog(logger, ...) getLogger(logger)->writeErrorLog(__FILENAME__ , (int)__LINE__, __FUNCTION__, __VA_ARGS__)
+#define assertErrorLog(c, logger, ...) ((c) || errorLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeErrorLog(logger, ...) (nullptr)
+#define errorLog(logger, ...) (nullptr)
 #define assertErrorLog(c, logger, ...) (c)
 #endif
 
 #if !aFunOFFAllLog
-#define writeSendErrorLog(logger, ...) writeSendErrorLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
-#define writeFatalErrorLog(logger, exit_code, ...) writeFatalErrorLog_(logger, file_line, __FUNCTION__, exit_code, __VA_ARGS__)
-#define assertSendErrorLog(c, logger, ...) ((c) || writeSendErrorLog(logger, "Assert " #c " error : " __VA_ARGS__))
-#define assertFatalErrorLog(c, logger, exit_code, ...) ((c) || writeFatalErrorLog(logger, exit_code, "Assert " #c " error : " __VA_ARGS__))
+#define sendErrorLog(logger, ...) getLogger(logger)->writeSendErrorLog(__FILENAME__ , (int)__LINE__, __FUNCTION__, __VA_ARGS__)
+#define fatalErrorLog(logger, exit_code, ...) getLogger(logger)->writeFatalErrorLog(__FILENAME__ , (int)__LINE__, __FUNCTION__, exit_code, __VA_ARGS__)
+#define assertSendErrorLog(c, logger, ...) ((c) || sendErrorLog(logger, "Assert " #c " error : " __VA_ARGS__))
+#define assertFatalErrorLog(c, logger, exit_code, ...) ((c) || fatalErrorLog(logger, exit_code, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeSendErrorLog(logger, ...) (nullptr)
-#define writeFatalErrorLog(logger, exit_code, ...) (nullptr)
+#define sendErrorLog(logger, ...) (nullptr)
+#define fatalErrorLog(logger, exit_code, ...) (nullptr)
 #define assertSendErrorLog(c, logger, ...) (c)
 #define assertFatalErrorLog(c, logger, exit_code, ...) (c)
 #endif
 
+#endif
 #endif //AFUN_LOG_HPP

include/tool/log_macro.hpp → include/tool/log_m.hpp

@@ -1,5 +1,5 @@
-#ifndef AFUN_LOG_MACRO_HPP
-#define AFUN_LOG_MACRO_HPP
+#ifndef AFUN_LOG_M_HPP
+#define AFUN_LOG_M_HPP
 
 #if (defined aFunOFFAllLog || defined aFunOFFLog)
 
@@ -144,4 +144,4 @@
 #define aFunConsoleFatalError 1
 #endif
 
-#endif //AFUN_LOG_MACRO_HPP
+#endif //AFUN_LOG_M_HPP

include/tool/macro.hpp

@@ -19,8 +19,10 @@
 #define NUL ((char)0)
 #define W_NUL ((wchar_t)0)
 
-typedef uint32_t FileLine;  // 文件行号
-typedef char *FilePath;  // 文件路径
-typedef const char *ConstFilePath;  // 文件路径
+namespace aFuntool {
+    typedef uint32_t FileLine;  // 文件行号
+    typedef std::string &FilePath;  // 文件路径
+    typedef const std::string &ConstFilePath;  // 文件路径
+}
 
 #endif //AFUN_MACRO_HPP

include/tool/md5.hpp

@@ -3,16 +3,21 @@
 #include "aFunToolExport.h"
 
 /* md5计算工具 */
-#define READ_DATA_SIZE	(1024)
-#define MD5_SIZE (16)
-#define MD5_STR_LEN (MD5_SIZE * 2)  // md5str的长度
-#define MD5_STRING (MD5_STR_LEN + 1)
 
-typedef struct MD5_CTX MD5_CTX;
+namespace aFuntool {
+    const int READ_DATA_SIZE = 1024;
+    const int MD5_SIZE = 16;
+    const int MD5_STR_LEN = MD5_SIZE * 2;
+    const int MD5_STRING = MD5_STR_LEN + 1;
 
-AFUN_TOOL_EXPORT MD5_CTX *MD5Init(void);
-AFUN_TOOL_EXPORT void MD5Final(MD5_CTX *context, unsigned char digest[16]);
-AFUN_TOOL_EXPORT void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int input_len);
-AFUN_TOOL_EXPORT char *getFileMd5(char *path);
+    typedef struct MD5_CTX MD5_CTX;
+
+    AFUN_TOOL_EXPORT MD5_CTX *MD5Init();
+    AFUN_TOOL_EXPORT void MD5Final(MD5_CTX *context, unsigned char digest[16]);
+    AFUN_TOOL_EXPORT void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int input_len);
+
+    template <typename T>
+    T getFileMd5(T &path);
+}
 
 #endif //AFUN_MD5_HPP

include/tool/mem.hpp

@@ -8,21 +8,28 @@
 
 #include <cstdlib>
 #include "log.hpp"
-#define free(p) ((((p)!=nullptr) ? (free(p), nullptr) : nullptr), (p)=nullptr)  // free不是可选的宏
 
-#if BUILD_MEM
 
 /* 取代calloc函数 */
-static void *safeCalloc(size_t n, size_t size);
-static void *safeCalloc(size_t n, size_t size) {
-    void *re = calloc(n, size);
-    if (re == nullptr)
-        writeFatalErrorLog(nullptr, EXIT_FAILURE, "The memory error");
-    return re;
+namespace aFuntool {
+    static void *safeFree(void *&ptr) {if (ptr != nullptr) free(ptr); ptr = nullptr; return nullptr;}
+    static void *safeCalloc(size_t n, size_t size){
+        void *re = calloc(n, size);
+        if (re == nullptr)
+            fatalErrorLog(nullptr, EXIT_FAILURE, "The memory error");
+        return re;
+    }
+
+    template <class T>
+    static void *safeCalloc(size_t n, T &t){
+        void *re = calloc(n, sizeof(decltype(*t)));  // 自动推断类型
+        if (re == nullptr)
+            fatalErrorLog(nullptr, EXIT_FAILURE, "The memory error");
+        return re;
+    }
 }
 
-#define calloc(n, obj) (obj *)(safeCalloc(n, sizeof(obj)))
-#define calloc_size(n, size) (safeCalloc(n, size))
+#define calloc(n, obj) (obj *)(aFuntool::safeCalloc(n, sizeof(obj)))
+#define calloc_size(n, size) (aFuntool::safeCalloc(n, size))
 
-#endif
 #endif  // AFUN_MEM_HPP

include/tool/path.hpp

@@ -5,22 +5,28 @@
 /* 路径工具 */
 #ifdef aFunWIN32_NO_CYGWIN
 
-#define SEP "\\"
-#define SEP_CH '\\'
+namespace aFuntool {
+    static const char *SEP = "\\";
+    static const char SEP_CH = '\\';
+}
 
 #else
 
-#define SEP "/"
-#define SEP_CH '/'
+namespace aFuntool {
+    const char *SEP = "/";
+    const char SEP_CH = '/';
+}
 
 #endif
 
-#define SHARED_PREFIX aFunSharePrefix
-#define SHARED_SUFFIX aFunShareSuffix
+namespace aFuntool {
+    static const char *SHARED_PREFIX = aFunSharePrefix;
+    static const char *SHARED_SUFFIX = aFunShareSuffix;
 
-#define STATIC_PREFIX aFunStaticPrefix
-#define STATIC_SUFFIX aFunStaticSuffix
+    static const char *STATIC_PREFIX = aFunStaticPrefix;
+    static const char *STATIC_SUFFIX = aFunStaticSuffix;
 
-#define EXE_SUFFIX aFunExeSuffix
+    static const char *EXE_SUFFIX = aFunExeSuffix;
+}
 
 #endif //AFUN_PATH_HPP

include/tool/regex.hpp

@@ -1,14 +1,44 @@
 #ifndef AFUN_REGEX
 #define AFUN_REGEX
 
-#define REGEX_ERROR_SIZE (512)
+#define PCRE2_CODE_UNIT_WIDTH 8
+#include "pcre2.h"
 
 #include "aFunToolExport.h"
 
-typedef struct af_Regex af_Regex;
+namespace aFuntool {
+    const int REGEX_ERROR_SIZE = 512;
 
-AFUN_TOOL_EXPORT af_Regex *makeRegex(const char *pattern, char **error);
-AFUN_TOOL_EXPORT void freeRegex(af_Regex *rg);
-AFUN_TOOL_EXPORT int matchRegex(const char *subject, af_Regex *rg, char **error);
+    class RegexException : public std::exception
+    {
+        std::string message = "Regex Error";
+    public:
+        explicit RegexException(std::string &msg) {
+            this->message = "RegexErrpr: " + msg;
+        }
+
+        explicit RegexException(const char *msg) {
+            this->message = std::string("RegexErrpr: ") + msg;
+        }
+
+        virtual const char *what() {
+            return message.c_str();
+        }
+    };
+
+    struct af_Regex {
+        pcre2_code *re;  // 正则表达式
+        char *pattern;  // 正则表达式的字符串
+    };
+
+    class Regex {
+        pcre2_code *re;  // 正则表达式
+        std::string pattern;  // 正则表达式的字符串
+    public:
+        explicit Regex(const std::string &pattern);
+        ~Regex();
+        int match(const char *subject);
+    };
+}
 
 #endif //AFUN_REGEX

include/tool/stdio_.hpp

@@ -1,20 +1,22 @@
-#ifndef AFUN_STDIO__H
-#define AFUN_STDIO__H
+#ifndef AFUN_STDIO_H
+#define AFUN_STDIO_H
 #include <cstdio>
 #include "base.h"
-
-AFUN_TOOL_EXPORT int fgets_stdin(char **dest, int len);
-AFUN_TOOL_EXPORT bool checkStdin();
-AFUN_TOOL_EXPORT bool fclear_stdin();
-
-#define CLEAR_FERROR(file) (ferror(file) && (clearerr(file), ferror(file)))  /* 出现错误后尝试修复, 并再次检查 */
-#define CLEAR_STDIN(file) ((ferror(stdin) || feof(stdin)) && (clearerr(stdin), (ferror(stdin) || feof(stdin))))
+#include "aFunToolExport.h"
+
+namespace aFuntool {
+    AFUN_TOOL_EXPORT int fgets_stdin(char **dest, int len);
+    AFUN_TOOL_EXPORT bool checkStdin();
+    AFUN_TOOL_EXPORT bool fclear_stdin();
+    static bool clear_ferror(FILE *file) {return ferror(file) && (clearerr(file), ferror(file));}
+    static bool clear_stdin() {
+        return (ferror(stdin) || feof(stdin)) &&
+                (clearerr(stdin), (ferror(stdin) || feof(stdin)));
+    }
+}
 
 #ifdef aFunWIN32_NO_CYGWIN
 
-AFUN_TOOL_EXPORT void stdio_signal_init(bool signal);
-AFUN_TOOL_EXPORT bool stdio_check_signal();
-
 #ifdef _MSC_VER
 #pragma warning(disable : 5105)  // 关闭 5105 的警告输出 (Windows.h中使用)
 #endif
@@ -22,39 +24,77 @@ AFUN_TOOL_EXPORT bool stdio_check_signal();
 #include <io.h>
 #include <Windows.h>
 
-AFUN_TOOL_EXPORT int convertMultiByte(char **dest, const char *str, UINT from, UINT to);  // win32 特有函数
-AFUN_TOOL_EXPORT int convertWideByte(wchar_t **dest, const char *str, UINT from);  // win32 特有函数
-AFUN_TOOL_EXPORT int convertFromWideByte(char **dest, const wchar_t *str, UINT to);
-
-AFUN_TOOL_EXPORT int fgetc_stdin();
-AFUN_TOOL_EXPORT char *fgets_stdin_(char *buf, size_t len);
-AFUN_TOOL_EXPORT int fungetc_stdin(int ch);
-
-AFUN_TOOL_EXPORT int fputs_std_(const char *str, FILE *std);
-#define fputs_stdout(std) fputs_std_(std, stdout)
-#define fputs_stderr(std) fputs_std_(std, stderr)
+namespace aFuntool {
+    AFUN_TOOL_EXPORT void stdio_signal_init(bool signal);
+    AFUN_TOOL_EXPORT bool stdio_check_signal();
+
+    AFUN_TOOL_EXPORT int convertMultiByte(char **dest, const char *str, UINT from, UINT to);  // win32 特有函数
+    AFUN_TOOL_EXPORT int convertWideByte(wchar_t **dest, const char *str, UINT from);  // win32 特有函数
+    AFUN_TOOL_EXPORT int convertFromWideByte(char **dest, const wchar_t *str, UINT to);
+
+    AFUN_TOOL_EXPORT int fgetc_stdin();
+    AFUN_TOOL_EXPORT char *fgets_stdin_(char *buf, size_t len);
+    AFUN_TOOL_EXPORT int fungetc_stdin(int ch);
+
+    AFUN_TOOL_EXPORT int fputs_std_(const char *str, FILE *std);
+    static int fputs_stdout(const char *str) {return fputs_std_(str, stdout);}
+    static int fputs_stderr(const char *str) {return fputs_std_(str, stderr);}
+
+    AFUN_TOOL_EXPORT size_t vprintf_std_(FILE *std, size_t buf_len, const char *format, va_list ap);
+    static size_t vprintf_stderr(size_t buf_len, const char *format, va_list ap) {
+        return vprintf_std_(stderr, buf_len, format, ap);
+    }
+    static size_t vprintf_stdout(size_t buf_len, const char *format, va_list ap) {
+        return vprintf_std_(stdout, buf_len, format, ap);
+    }
+
+    static size_t printf_stdout(size_t buf_len, const char *format, ...) {
+        va_list ap;
+        va_start(ap, format);
+        size_t re = vprintf_std_(stdout, buf_len, format, ap);
+        va_end(ap);
+        return re;
+    }
+
+    static size_t printf_stderr(size_t buf_len, const char *format, ...) {
+        va_list ap;
+        va_start(ap, format);
+        size_t re = vprintf_std_(stderr, buf_len, format, ap);
+        va_end(ap);
+        return re;
+    }
+}
 
+#else
 
-AFUN_TOOL_EXPORT size_t vprintf_std_(FILE *std, size_t buf_len, const char *format, va_list ap);
-#define vprintf_stderr(len, format, ap) vprintf_std_(stderr, len, format, ap)
-#define vprintf_stdout(len, format, ap) vprintf_std_(stdout, len, format, ap)
+namespace aFuntool {
+    static int fgetc_stdin(){ return fgetc(stdout); }
+    static int fgets_stdin_(char *buf, int len, FILE *file){ fgets(buf, len, file); }
+    static int fungetc_stdin(char ch){ return ungetc(ch, stdin); }
 
+    static int fputs_stdout(const char *str){ return fputs(str, stdout); }
+    static int fputs_stderr(const char *str){ return fputs(str, stderr); }
 
-AFUN_TOOL_EXPORT size_t printf_stdout(size_t buf_len, const char *format, ...);
-AFUN_TOOL_EXPORT size_t printf_stderr(size_t buf_len, const char *format, ...);
+    static int vprintf_stdout(size_t, const char *format, va_list ap){ return vfprintf(stdout, format, ap); }
+    static int vprintf_stderr(size_t, const char *format, va_list ap){ return vfprintf(stderr, format, ap); }
 
-#else
-#define fgetc_stdin() fgetc(stdin)
-#define fgets_stdin_(buf, len, stream) fgets(buf, len, stream)
-#define fungetc_stdin(ch) ungetc((ch), stdin)
+    static size_t printf_stdout(size_t, const char *format, ...) {
+        va_list ap;
+        va_start(ap, format);
+        size_t re = vfprintf(stdout, format, ap);
+        va_end(ap);
+        return re;
+    }
 
-#define fputs_stdout(str) fputs((str), stdout)
-#define fputs_stderr(str) fputs((str), stderr)
+    static size_t printf_stderr(size_t, const char *format, ...) {
+        va_list ap;
+        va_start(ap, format);
+        size_t re = vfprintf(stderr, format, ap);
+        va_end(ap);
+        return re;
+    }
 
-#define vprintf_stdout(buf_len, format, ap) vfprintf(stdout, (format), (ap))
-#define vprintf_stderr(buf_len, format, ap) vfprintf(stderr, (format), (ap))
-#define printf_stdout(buf_len, ...) fprintf(stdout, __VA_ARGS__)
-#define printf_stderr(buf_len, ...) fprintf(stderr, __VA_ARGS__)
+}
 
 #endif
-#endif //AFUN_STDIO__H
+#endif //AFUN_STDIO_H

include/tool/str.hpp

@@ -5,20 +5,13 @@
 #include "aFunToolExport.h"
 
 /* 字符串工具 */
-#define EQ_STR(str1, str2) (!strcmp((str1), (str2)))
-#define EQ_WSTR(wid1, wid2) (!wcscmp((wid1), (wid2)))
 
-#define NEW_STR(size) calloc((size) + 1, char)
-#define NEW_WSTR(size) calloc((size) + 1, wchar_t)
-
-#define STR_LEN(p) (((p) == NULL) ? 0 : strlen((p)))
-#define WSTR_LEN(p) (((p) == NULL) ? 0 : wcslen((p)))
-
-AFUN_TOOL_EXPORT char *charToStr(char ch);
-AFUN_TOOL_EXPORT char *strCopy(const char *str);
-AFUN_TOOL_EXPORT char *strJoin(const char *first, const char *second, bool free_first, bool free_last);
-AFUN_TOOL_EXPORT char *strJoin_(const char *first, const char *second, bool free_first, bool free_last);
-AFUN_TOOL_EXPORT wchar_t *convertToWstr(const char *str, bool free_old);
-AFUN_TOOL_EXPORT char *convertToStr(const wchar_t *wstr, bool free_old);
+namespace aFuntool {
+    AFUN_TOOL_EXPORT char *charToStr(char ch);
+    AFUN_TOOL_EXPORT char *strCopy(const char *str);
+    AFUN_TOOL_EXPORT char *strJoin(const char *first, const char *second, bool free_first, bool free_last);
+    AFUN_TOOL_EXPORT wchar_t *convertToWstr(const char *str, bool free_old);
+    AFUN_TOOL_EXPORT char *convertToStr(const wchar_t *wstr, bool free_old);
+}
 
 #endif //AFUN_STR_HPP

include/tool/time_s.hpp

@@ -3,6 +3,9 @@
 #include "aFunToolExport.h"
 
 /* 时间工具 */
-AFUN_TOOL_EXPORT void safeSleep(double ms);
-AFUN_TOOL_EXPORT char *getTime(time_t *t, const char *format);
+namespace aFuntool {
+    AFUN_TOOL_EXPORT void safeSleep(double ms);
+    AFUN_TOOL_EXPORT char *getTime(time_t *t, const char *format);
+    AFUN_TOOL_EXPORT std::string getTime(time_t *t, const std::string &format);
+}
 #endif //AFUN_TIME_H

include/tool/tool.hpp

@@ -26,7 +26,6 @@
 
 #include "pthread.h"
 #include "fflags.h"
-
 #include "aFun_ht.h"
 
 #endif //AFUN_TOOL_HPP

src/CMakeLists.txt

@@ -20,41 +20,42 @@ set(build_include)
 foreach(dir IN LISTS build_include_)
     list(APPEND build_include $<BUILD_INTERFACE:${dir}>)
 endforeach()
+unset(build_include_)
 
 set(install_include $<INSTALL_INTERFACE:${INSTALL_INCLUDEDIR}>)
 
 add_subdirectory(tool)
-add_subdirectory(core)  # core 依赖 tool
-add_subdirectory(runtime)  # runtime 依赖 core
+#add_subdirectory(core)  # core 依赖 tool
+#add_subdirectory(runtime)  # runtime 依赖 core
 
 # source在子目录中被使用, 为了避免子目录访问到source, 子目录将在此前面被执行
-file(GLOB source
-     LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.cpp)
-
-file(GLOB private_h
-     LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.hpp)
-
-file(GLOB include_h
-     LIST_DIRECTORIES FALSE
-     "${PROJECT_SOURCE_DIR}/include/*.hpp")
-
-add_executable(aFun-xx "")  # xx表示均为动态链接
-add_executable(aFun-ct "")  # ct表示均静态链接
-set(aFunList aFun-xx aFun-ct)
-
-foreach(tgt IN LISTS aFunList)
-    target_sources(${tgt} PRIVATE ${source} ${private_h} ${include_h})
-    target_include_directories(${tgt} PRIVATE ${PROJECT_SOURCE_DIR}/include)
-    set_target_properties(${tgt} PROPERTIES PUBLIC_HEADER "${include_h}")
-    define_FILENAME(${tgt})
-endforeach()
-
-target_link_libraries(aFun-xx PUBLIC rt-shared)
-target_link_libraries(aFun-ct PUBLIC rt-static)
-
-install(TARGETS aFun-xx aFun-ct
-        RUNTIME DESTINATION ${INSTALL_BINDIR} COMPONENT advanced-runtime
-        PUBLIC_HEADER DESTINATION ${INSTALL_INCLUDEDIR} COMPONENT dev
-        PRIVATE_HEADER DESTINATION ${INSTALL_INCLUDEDIR} COMPONENT advanced-dev)
+#file(GLOB source
+#     LIST_DIRECTORIES FALSE
+#     ${CMAKE_CURRENT_LIST_DIR}/*.cpp)
+#
+#file(GLOB private_h
+#     LIST_DIRECTORIES FALSE
+#     ${CMAKE_CURRENT_LIST_DIR}/*.hpp)
+#
+#file(GLOB include_h
+#     LIST_DIRECTORIES FALSE
+#     "${PROJECT_SOURCE_DIR}/include/*.hpp")
+#
+#add_executable(aFun-xx "")  # xx表示均为动态链接
+#add_executable(aFun-ct "")  # ct表示均静态链接
+#set(aFunList aFun-xx aFun-ct)
+#
+#foreach(tgt IN LISTS aFunList)
+#    target_sources(${tgt} PRIVATE ${source} ${private_h} ${include_h})
+#    target_include_directories(${tgt} PRIVATE ${PROJECT_SOURCE_DIR}/include)
+#    set_target_properties(${tgt} PROPERTIES PUBLIC_HEADER "${include_h}")
+#    define_FILENAME(${tgt})
+#endforeach()
+#
+#target_link_libraries(aFun-xx PUBLIC rt-shared)
+#target_link_libraries(aFun-ct PUBLIC rt-static)
+#
+#install(TARGETS aFun-xx aFun-ct
+#        RUNTIME DESTINATION ${INSTALL_BINDIR} COMPONENT advanced-runtime
+#        PUBLIC_HEADER DESTINATION ${INSTALL_INCLUDEDIR} COMPONENT dev
+#        PRIVATE_HEADER DESTINATION ${INSTALL_INCLUDEDIR} COMPONENT advanced-dev)

src/core/__code.hpp

@@ -1,33 +0,0 @@
-/*
- * 文件名: __code.h
- * 目标: 定义Code结构体
- */
-
-#ifndef AFUN_BYTECODE_H_
-#define AFUN_BYTECODE_H_
-#include "tool.hpp"
-#include "code.hpp"
-
-struct af_Code {  // 一个 Code 的结构体
-    enum af_CodeType type;
-    char prefix;  // 前缀
-    CodeUInt code_end;  // 记录block的end
-    union {
-        struct {
-            char *data;
-        } element;
-
-        struct {
-            bool is_empty;
-            enum af_BlockType type;  // 括号类型
-        } block;
-    };
-
-    FileLine line;
-    FilePath path;  // path == nullptr表示沿用上层地址
-
-    struct af_Code *prev;
-    struct af_Code *next;
-};
-
-#endif //AFUN_BYTECODE_H_

src/core/__env.hpp

@@ -1,347 +0,0 @@
-#ifndef AFUN_ENV_H_
-#define AFUN_ENV_H_
-#include "tool.hpp"
-#include "pthread.h"
-
-typedef struct af_Activity af_Activity;
-typedef struct af_ActivityTrackBack af_ActivityTrackBack;
-typedef struct af_EnvVarSpace af_EnvVarSpace;
-typedef struct af_EnvVar af_EnvVar;
-typedef struct af_TopMsgProcess af_TopMsgProcess;
-typedef struct af_Guardian af_Guardian;
-typedef struct af_LiteralDataList af_LiteralDataList;
-typedef struct af_LiteralRegex af_LiteralRegex;
-typedef struct af_ErrorBacktracking af_ErrorBacktracking;
-typedef struct af_EnvironmentList af_EnvironmentList;
-
-#include "env.hpp"
-#include "__object.hpp"
-#include "__var.hpp"
-#include "__code.hpp"
-#include "__gc.hpp"
-#include "__func.hpp"
-#include "__monitor.hpp"
-#include "regex.hpp"
-
-#define DEFAULT_GC_COUNT_MAX (50)
-#define ENV_VAR_HASH_SIZE (8)
-typedef uint16_t ActivityCount;
-
-struct af_Message {
-    char *type;  // 消息类型
-    void *msg;  // 信息内容
-    size_t size;
-    struct af_Message *next;
-};
-
-struct af_LiteralDataList {
-    char *literal_data;
-    struct af_LiteralDataList *next;
-};
-
-struct af_GuardianList {
-    struct af_Object *obj;
-    struct af_Object *func;
-    struct af_GuardianList *next;
-};
-
-enum af_ActivityType {
-    act_top = 0,  /* 顶层 永远存在第一层 */
-    act_func,  /* 函数调用 */
-    act_top_import,  /* 导入 运算结束后global进入msg反 */
-    act_guardian,  /* 守护器 */
-};
-
-enum af_ActivityStatus {
-    act_func_get = 0,
-    act_func_arg,
-    act_func_normal,
-};
-
-struct af_Activity {  // 活动记录器
-    struct af_Activity *prev;  // 上一个活动记录器
-
-    enum af_ActivityType type;
-
-    /* gc锁, 保护belong, run_varlist, func, return_obj, parentheses_call, macro_varlist func_varlist out_varlist gl pgl*/
-    pthread_mutex_t *gc_lock;  // gc线程读时上锁, 解释器所在线程读时不上锁, 写时上锁 【本质是 Env 的 gc 锁】
-    struct af_Object *belong;  // 属对象 (belong通常为func的belong)
-
-    struct af_Message *msg_down;  // 被调用者向调用者传递信息
-    struct af_Message *msg_up;  // 调用者向被调用者传递信息
-    ActivityCount msg_up_count;  // msg_up 添加的个数
-
-    struct af_VarList *run_varlist;  // 主变量空间
-    ActivityCount count_run_varlist;  // 需要释放的空间数
-
-    FilePath file;
-    FileLine line;
-
-    bool is_guard;  // 当为true时将不执行守护器
-
-    union {
-        struct {  // 仅守护器使用
-            struct af_GuardianList *gl;
-            struct af_GuardianList **pgl;  // 执行gl的最末端
-            struct af_GuardianList *gl_next;  // gl执行的位置
-        };
-
-        struct {  // gc以外的其他内容使用
-            enum af_ActivityStatus status;
-
-            struct af_Object *func;  // 函数本身
-
-            bool run_in_func;  // 在函数变量空间内运行 (act_arg用)
-            struct af_VarList *out_varlist;  // 变量空间
-            ActivityCount count_out_varlist;  // 需要释放的空间数
-
-            struct af_VarList *func_varlist;  // 函数内部变量空间 (运行函数体时会设置为 主变量空间)
-
-            struct af_Code *bt_top;  // 最顶层设置为nullptr, 函数调用设置为block, (bt_start的上一个元素) [只在函数调用的非NORMAL期有用]
-            struct af_Code *bt_start;  // 代码的起始位置 (block的第一个元素)
-            struct af_Code *bt_done;  // 当前正在执行的代码
-            struct af_Code *bt_next;  // 指示代码下一步要运行的位置 [总是超前当前执行的code]
-
-            /* 返回值 */
-            bool return_first;  // 顺序执行, 获取第一个返回结果
-            struct af_Object *return_obj;  // 调用者向被调用者传递信息
-            size_t process_msg_first;  // 优先处理msg而不是code
-
-            /* 函数调用: 常规 */
-            enum af_BlockType call_type;  // 函数调用类型
-            struct af_Object *parentheses_call;  // 类前缀调用
-            struct af_ArgCodeList *acl_start;
-            struct af_ArgCodeList *acl_done;  // 记录当前运行的acl [总是与当前执行的acl同步] [acl代码执行完成后需要把结果写入acl, 故不超前]
-            struct af_FuncInfo *fi;
-            struct af_FuncBody *body_next;  // 下一个需要执行的body [总是超前当前执行的body]
-            void *mark;  // 标记 [完全由API管理, 不随activity释放]
-
-            /* 函数调用: 宏函数*/
-            bool is_macro_call;  // 宏函数隐式调用
-            struct af_VarList *macro_varlist;  // 宏函数执行的vsl (即调用函数时的外部VarLis)
-            ActivityCount count_macro_varlist;  // 需要释放的空间数
-
-            /* 函数调用: 析构函数 在错误回溯时使用, 是个标记*/
-            bool is_gc_call;
-            bool is_guard_call;
-
-            /* 字面量 */
-            bool is_literal;  // 处于字面量运算 意味着函数调用结束后会调用指定API
-            struct af_LiteralDataList *ld;
-
-            /* 变量 */
-            bool is_obj_func;  // 对象函数的调用
-
-            /* 顺序执行 */
-            bool is_execution;
-
-            /* 尾调用优化 */
-            bool optimization;
-
-            /* Import使用 */
-            char *import_mark;
-
-            struct af_ActivityTrackBack *tb;
-        };
-    };
-};
-
-struct af_ActivityTrackBack {
-    /* 记录Activity尾调用优化的回溯信息 */
-    /* af_ActivityType不用记录, 因为必定是act_func */
-
-    FilePath file;
-    FileLine line;
-    enum af_ActivityStatus status;
-    bool return_first;
-    bool run_in_func;
-    bool is_macro_call;  // 宏函数隐式调用
-    bool is_gc_call;
-    bool is_literal;  // 处于字面量运算 意味着函数调用结束后会调用指定API
-    bool is_obj_func;  // 对象函数的调用
-    bool is_execution;
-    bool optimization;
-
-    struct af_ActivityTrackBack *next;
-};
-
-typedef void TopMsgProcessFunc(af_Message *msg, bool is_top, af_Environment *env);
-NEW_DLC_SYMBOL(TopMsgProcessFunc, TopMsgProcessFunc);
-
-typedef af_GuardianList *GuardianFunc(const char *type, bool is_guard, void *data, af_Environment *env);
-NEW_DLC_SYMBOL(GuardianFunc, GuardianFunc);
-
-typedef void GuardianDestruct(const char *type, void *data, af_Environment *env);
-NEW_DLC_SYMBOL(GuardianDestruct, GuardianDestruct);
-
-struct af_TopMsgProcess {  // 顶层msg处理器
-    char *type;
-    DLC_SYMBOL(TopMsgProcessFunc) func;
-    struct af_TopMsgProcess *next;
-};
-
-struct af_Guardian {  // 守护器
-    char *type;
-    void *data;
-    size_t size;
-    DLC_SYMBOL(GuardianFunc) func;
-    DLC_SYMBOL(GuardianDestruct) destruct;
-    bool always;  // 是否总是运行
-    bool derive;  // 是否支持派生
-    struct af_Guardian *next;
-};
-
-struct af_EnvVar {  // 环境变量
-    char *name;
-    char *data;
-    int32_t num;  // 可以同时记录字符串和数字
-    struct af_EnvVar *next;
-};
-
-struct af_EnvVarSpace {  // 环境变量
-    size_t count;
-    struct af_EnvVar *(var[ENV_VAR_HASH_SIZE]);
-    pthread_rwlock_t lock;
-};
-
-struct af_EnvironmentList {
-    size_t id;
-    struct af_Environment *env;
-    struct af_EnvironmentList *next;
-    struct af_EnvironmentList *prev;
-};
-
-enum af_CoreStatus {
-    core_creat = 0,
-    core_init,  // 执行初始化程序
-    core_normal,  // 正常执行
-    core_normal_gc,  // 正常执行
-    core_stop,  // 当前运算退出
-    core_exit,  // 解释器退出
-};
-
-struct af_Environment {  // 运行环境
-    af_Monitor *monitor;  // 监视器线程
-
-    bool is_derive;  // 是否派生
-    struct af_Environment *base;  // 主线程
-    struct af_Environment *gc_env;  // 主线程的 gc线程
-
-    struct af_Object *result;  // 线程执行的结果
-    struct af_EnvironmentList *env_list;  // 主线程记录所有的子线程
-    bool all_exit;  // 由线程自己控制, 用于通知子线程退出
-    bool son_exit;  // 由线程外部控制, 命令线程结束
-    pthread_mutex_t thread_lock;  // 保护 father_exit 和 son_exit 和 son_count
-
-    enum af_CoreStatus status;
-    pthread_mutex_t status_lock;
-
-    /* 保护空间 */
-    struct af_VarSpace *protect;  // 顶级保护变量空间
-
-    /* 数据 */
-    af_EnvVar *gc_count;
-    af_EnvVar *gc_max;
-    af_EnvVar *gc_runtime;
-    af_EnvVar *prefix;
-    af_EnvVar *exit_code_;  // 退出代码
-    af_EnvVar *argc;  // 参数个数
-    af_EnvVar *error_std;  // Error输出的位置 0-stdout 其他-stderr
-
-    /* 基本对象信息 */
-    struct af_Object *global;  // 顶级属对象
-
-    /* 字面量基本信息 */
-    af_LiteralRegex *lr;
-
-    struct gc_Factory *gc_factory;  // 记录gc信息
-
-    struct af_EnvVarSpace *esv;
-    struct af_TopMsgProcess *process;
-    struct af_Guardian *guardian;
-    struct af_Activity *activity;
-    pthread_mutex_t in_run;
-};
-
-struct af_LiteralRegex {
-    af_Regex *rg;
-    char *pattern;  // 派生 LiteralRegex 时实用
-    char *func;  // 调用的函数
-    bool in_protect;  // 是否在protect空间
-    struct af_LiteralRegex *next;
-};
-
-struct af_ErrorBacktracking {
-    FilePath file;
-    FileLine line;
-    char *note;  // 备注信息
-    struct af_ErrorBacktracking *next;
-};
-
-struct af_ErrorInfo {
-    char *error_type;
-    char *error;
-    struct af_ErrorBacktracking *track;
-    af_Object *obj;  // 代表错误的obj对象
-};
-
-struct af_ImportInfo {
-    char *mark;
-    af_Object *obj;
-};
-
-/* Core 管理函数 */
-AFUN_CORE_NO_EXPORT void GcCountAdd1(af_Environment *env);
-AFUN_CORE_NO_EXPORT void GcCountToZero(af_Environment *env);
-AFUN_CORE_NO_EXPORT enum af_CoreStatus getCoreStatus(af_Environment *env);
-
-/* 运行时Activity设置函数 (新增Activity) */
-AFUN_CORE_NO_EXPORT bool pushExecutionActivity(af_Code *bt, bool return_first, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool pushFuncActivity(af_Code *bt, af_Environment *env);
-AFUN_CORE_NO_EXPORT void popActivity(bool is_normal, af_Message *msg, af_Environment *env);
-
-/* 运行时Activity设置函数 (设置Activity) */
-AFUN_CORE_NO_EXPORT bool pushGuadianFuncActivity(af_GuardianList *gl, af_Environment *env);
-AFUN_CORE_NO_EXPORT void pushGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool pushVariableActivity(af_Code *bt, af_Object *func, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool pushLiteralActivity(af_Code *bt, const char *data, af_Object *func, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool pushMacroFuncActivity(af_Object *func, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool pushImportActivity(af_Code *bt, af_Object **obj, const char *mark, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool setFuncActivityToArg(af_Object *func, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool setFuncActivityAddVar(af_Environment *env);
-AFUN_CORE_NO_EXPORT int setFuncActivityToNormal(af_Environment *env);
-AFUN_CORE_NO_EXPORT void setArgCodeListToActivity(af_ArgCodeList *acl, af_Environment *env);
-
-/* 运行时Activity设置函数 (设置Activity的行号和文件) */
-AFUN_CORE_NO_EXPORT void setActivityBtTop(af_Code *bt_top, af_Activity *activity);
-AFUN_CORE_NO_EXPORT void setActivityBtStart(af_Code *bt_start, af_Activity *activity);
-AFUN_CORE_NO_EXPORT void setActivityBtNext(af_Code *bt_next, af_Activity *activity);
-
-/* LiteralData 释放函数 */
-AFUN_CORE_NO_EXPORT void freeAllLiteralData(af_LiteralDataList *ld);
-
-/* LiteralData 相关操作 */
-AFUN_CORE_NO_EXPORT void pushLiteralData(char *data, af_Environment *env);
-AFUN_CORE_NO_EXPORT bool checkLiteralCode(const char *literal, char **func, bool *in_protect, af_Environment *env);
-
-/* 顶层消息处理器 处理函数 */
-AFUN_CORE_NO_EXPORT void runTopMessageProcess(bool is_top, af_Environment *env);
-
-/* 消息 创建与释放 */
-AFUN_CORE_NO_EXPORT void freeAllMessage(af_Message *msg);
-
-/* 消息管理函数 */
-AFUN_CORE_NO_EXPORT void connectMessage(af_Message **base, af_Message *msg);
-
-/* 环境变量管理函数 */
-AFUN_CORE_NO_EXPORT af_EnvVar *setEnvVarNumber_(const char *name, int32_t data, af_Environment *env);
-AFUN_CORE_NO_EXPORT af_EnvVar *setEnvVarData_(const char *name, const char *data, af_Environment *env);
-
-/* af_GuardianList管理函数 */
-AFUN_CORE_NO_EXPORT af_GuardianList **contectGuardianList(af_GuardianList *new_gl, af_GuardianList **base);
-
-/* EnvironmentList 管理函数 */
-AFUN_CORE_NO_EXPORT bool freeEnvironmentListByEnv(af_Environment *env, af_Environment *base);
-AFUN_CORE_NO_EXPORT void pushEnvironmentList(af_Environment *env, af_Environment *base);
-
-#endif //AFUN_ENV_H_

src/core/__func.hpp

@@ -1,68 +0,0 @@
-#ifndef AFUN_FUNC_H_
-#define AFUN_FUNC_H_
-#include "tool.hpp"
-
-#include "func.hpp"
-#include "__object.hpp"
-#include "__code.hpp"
-
-struct af_ArgCodeList {
-    void *info;  // info信息
-    size_t size;
-
-    struct af_Code *code;
-    bool free_code;  // code 是否释放
-    bool run_in_func;  // 是否在函数的变量空间内运行
-
-    struct af_Object *result;  // 有gc引用计数
-    struct af_ArgCodeList *next;
-};
-
-struct af_ArgList {
-    char *name;
-    struct af_Object *obj;  // 有gc引用计数
-    struct af_ArgList *next;
-};
-
-enum af_FuncBodyType {
-    func_body_c = 0,  // 回调C函数
-    func_body_code,  // 执行af_Code
-    func_body_import,  // import内容
-    func_body_dynamic,
-};
-
-struct af_FuncBody {
-    enum af_FuncBodyType type;
-
-    union {
-        DLC_SYMBOL(callFuncBody) c_func;
-        struct {
-            af_Code *code;
-            bool free_code;
-        };
-    };
-
-    char **msg_type;  // 表示对应函数可以处理的msg类型
-    struct af_FuncBody *next;
-};
-
-struct af_FuncInfo {
-    // 函数属性
-    enum af_FuncInfoScope scope;  // 定义在 func.h
-    enum af_FuncInfoEmbedded embedded;  // 定义在 func.h
-    bool is_macro;  // 宏函数
-
-    bool var_this;  // 是否写入self参数
-    bool var_func;  // 是否写入func参数
-
-    // 函数信息
-    struct af_FuncBody *body;
-};
-
-/* FuncInfo 相关操作 */
-AFUN_CORE_NO_EXPORT bool pushDynamicFuncBody(af_FuncBody *new_fb, af_FuncBody *body);
-
-/* ArgList 相关操作 */
-AFUN_CORE_NO_EXPORT bool runArgList(af_ArgList *al, af_VarList *vsl, af_Environment *env);
-
-#endif //AFUN_FUNC_H_

src/core/__gc.hpp

@@ -1,103 +0,0 @@
-#ifndef AFUN_GC_H_
-#define AFUN_GC_H_
-#include "tool.hpp"
-#include "pthread.h"
-
-typedef struct GC_Var GC_Var;
-typedef struct GC_VarSpace GC_VarSpace;
-typedef struct GC_Object GC_Object;
-typedef struct GC_ObjectData GC_ObjectData;
-typedef struct af_GcList af_GcList;
-typedef struct gc_Analyzed gc_Analyzed, **pgc_Analyzed;
-typedef struct gc_Factory gc_Factory;
-
-#define GC_CHAIN(type) struct type *next, *prev
-typedef uint32_t GcCount;
-
-struct gc_info {
-    bool not_clear;  // 不清除
-    GcCount reference;  // 引用计数
-    bool reachable;  // 可达标记 [同时标识已迭代]
-};
-
-struct GC_ObjectData {
-    struct gc_info info;
-    GC_CHAIN(af_ObjectData);
-    bool done_destruct;  // 是否已析构
-};
-
-struct GC_Object {
-    struct gc_info info;
-    GC_CHAIN(af_Object);
-};
-
-struct GC_Var {
-    struct gc_info info;
-    GC_CHAIN(af_Var);
-};
-
-
-struct GC_VarSpace {
-    struct gc_info info;
-    GC_CHAIN(af_VarSpace);
-};
-
-#undef GC_CHAIN
-
-#include "__env.hpp"  // 这部分内容依赖上面的定义
-#include "gc.hpp"
-
-struct af_GcList {
-    enum af_GcListType type;
-
-    union {
-        void *data;
-        struct af_Object *obj;
-        struct af_VarSpace *vs;
-        struct af_Var *var;
-        struct af_VarList *vsl;
-    };
-
-    struct af_GcList *next;
-};
-
-struct gc_Analyzed {
-    struct af_Object *obj;
-    struct gc_Analyzed *next;
-};
-
-struct gc_Factory {
-    pthread_mutex_t mutex;  // 互斥锁, 保护下面字段
-    struct af_ObjectData *gc_ObjectData;
-    struct af_Object *gc_Object;
-    struct af_Var *gc_Var;
-    struct af_VarSpace *gc_VarSpace;
-};
-
-/* gc_Factory 创建与释放 */
-AFUN_CORE_NO_EXPORT gc_Factory *makegGcFactory(void);
-AFUN_CORE_NO_EXPORT void freeGcFactory(gc_Factory *factory);
-
-/* gc 对象新增函数 */
-AFUN_CORE_NO_EXPORT void gc_addObject(af_Object *obj, af_Environment *base);
-AFUN_CORE_NO_EXPORT void gc_addVar(af_Var *obj, af_Environment *base);
-AFUN_CORE_NO_EXPORT void gc_addVarSpace(af_VarSpace *obj, af_Environment *base);
-AFUN_CORE_NO_EXPORT void gc_addObjectData(struct af_ObjectData *obj, af_Environment *base);
-
-AFUN_CORE_NO_EXPORT void gc_delObject(af_Object *obj, af_Environment *base);
-AFUN_CORE_NO_EXPORT void gc_delVar(af_Var *obj, af_Environment *base);
-AFUN_CORE_NO_EXPORT void gc_delVarSpace(af_VarSpace *obj, af_Environment *base);
-AFUN_CORE_NO_EXPORT void gc_delObjectData(struct af_ObjectData *obj, af_Environment *base);
-
-/* gc Reference 管理函数 : 涉及af_ObjectData 不对外公开 */
-AFUN_CORE_NO_EXPORT void gc_addObjectDataReference(af_ObjectData *obj, af_Environment *base);
-AFUN_CORE_NO_EXPORT void gc_delObjectDataReference(af_ObjectData *obj, af_Environment *base);
-
-/* gc 操控函数 */
-AFUN_CORE_NO_EXPORT paf_GuardianList checkAllDestruct(af_Environment *env, paf_GuardianList pgl);
-AFUN_CORE_NO_EXPORT void gc_freeAllValueData(af_Environment *env);
-AFUN_CORE_NO_EXPORT void gc_freeAllValue(af_Environment *env);
-
-/* gc 信息函数 */
-AFUN_CORE_NO_EXPORT void printGCByCore(af_Environment *env);
-#endif //AFUN_GC_H_

src/core/__global_obj.hpp

@@ -1,4 +0,0 @@
-#ifndef AFUN_GLOBAL_OBJ_H_
-#define AFUN_GLOBAL_OBJ_H_
-#include "global_obj.hpp"
-#endif //AFUN_GLOBAL_OBJ_H_

src/core/__monitor.hpp

@@ -1,20 +0,0 @@
-#ifndef AFUN___MONITOR_HPP
-#define AFUN___MONITOR_HPP
-#include "pthread.h"
-#include "macro.hpp"
-
-typedef struct af_Monitor af_Monitor;
-struct af_Monitor {
-    struct af_Environment *env;
-    pthread_t thread;
-    bool exit;  // 外部通知守护线程结束
-    pthread_mutex_t lock;
-    pthread_cond_t cond;
-};
-
-
-#include "__env.hpp"
-AFUN_CORE_NO_EXPORT af_Monitor *makeMonitor(af_Environment *env);
-AFUN_CORE_NO_EXPORT void freeMonitor(af_Environment *env);
-
-#endif //AFUN___MONITOR_HPP

src/core/__object.hpp

@@ -1,83 +0,0 @@
-/*
- * 文件名: __object.h
- * 目标: 定义aft对象的结构体
- */
-
-#ifndef AFUN_OBJECT_H_
-#define AFUN_OBJECT_H_
-#include "tool.hpp"
-#include "obj_api.h"  // 该文件不包含在object.h中, object.h并不依赖该文件
-
-// 这些typedef可能会被下面include的文件使用
-typedef struct af_ObjectData af_ObjectData;
-typedef struct af_ObjectAPINode af_ObjectAPINode;
-
-#include "object.hpp"
-#include "__gc.hpp"
-#include "pthread.h"
-
-#define API_HASHTABLE_SIZE (8)
-
-typedef void objectAPIFunc();
-NEW_DLC_SYMBOL(objectAPIFunc, objectAPIFunc);
-
-struct af_ObjectAPINode {
-    char *name;  // api名字
-    DLC_SYMBOL(objectAPIFunc) api;  // api函数
-    struct af_ObjectAPINode *next;
-};
-
-struct af_ObjectAPI {
-    ObjAPIUint count;  // api个数记录
-    struct af_ObjectAPINode *(node[API_HASHTABLE_SIZE]);
-    pthread_rwlock_t lock;
-};
-
-struct af_ObjectData {
-    std::string id;  // 对象类型标识符(一个字符串)
-
-    void *data;
-    size_t size;  // 标记data的大小
-
-    struct af_ObjectAPI *api;  // 继承的api必须位于Inherit链中
-    bool allow_inherit;  // 是否允许被继承
-    bool free_api;  // 是否释放api
-
-    struct af_Inherit *inherit;  // 只有顶级继承对象的inherit属性可为nullptr
-    bool free_inherit;  // 是否释放inherit
-
-    struct af_VarSpace *var_space;
-
-    struct af_Object *base;  // 在gc机制中, 当对想要被释放前, 调用析构函数是对象以该base的身份出现
-    pthread_rwlock_t lock;  // 保护除gc外其他字段
-
-    GC_ObjectData gc;
-};
-
-struct af_Object {
-    struct af_Object *belong;  // 只有顶级属对象的belong属性可为nullptr
-    struct af_ObjectData *data;
-    pthread_rwlock_t lock;  // 保护上面两个字段
-
-    GC_Object gc;
-};
-
-struct af_Inherit {
-    struct af_Object *obj;
-    struct af_VarSpace *vs;  // 共享变量空间
-    struct af_Inherit *next;
-    pthread_rwlock_t lock;
-};
-
-/* 对象 创建与释放 */
-AFUN_CORE_NO_EXPORT void freeObject(af_Object *obj, af_Environment *env);
-
-/* ObjectData 属性访问 */
-AFUN_CORE_NO_EXPORT af_Object *findObjectAttributesByObjectData(const char *name, af_Object *visitor, af_ObjectData *od,
-                                                                af_Environment *env);
-
-/* ObjectData 释放函数 */
-AFUN_CORE_NO_EXPORT void freeObjectDataData(af_ObjectData *od, af_Environment *env);
-AFUN_CORE_NO_EXPORT void freeObjectData(af_ObjectData *od, af_Environment *env);
-
-#endif //AFUN_OBJECT_H_

src/core/__parser.hpp

@@ -1,65 +0,0 @@
-#ifndef AFUN_PARSER_H_
-#define AFUN_PARSER_H_
-#include <stdio.h>
-#include "__reader.hpp"
-#include "token.h"
-#include "parser.hpp"
-
-enum af_LexicalStatus {
-    lex_begin = 0,  // 起始类型
-    lex_prefix_block_p = 1,  // 前缀括号 !
-    lex_prefix_block_b = 2,  // 前缀括号 @
-    lex_prefix_block_c = 3,  // 前缀括号 #
-    lex_comment_before = 4,  // 注释
-    lex_element_long = 5,
-    lex_mutli_comment = 6,  // 多行注释
-    lex_uni_comment = 7,  // 当行注释
-    lex_mutli_comment_end_before = 8,  // 多行注释遇到;
-
-    lex_prefix = -1,  // prefix类型
-    lex_lp = -2,
-    lex_lb = -3,
-    lex_lc = -4,
-    lex_rp = -5,
-    lex_rb = -6,
-    lex_rc = -7,
-    lex_space = -8,
-    lex_uni_comment_end = -9,
-    lex_mutli_comment_end = -10,
-    lex_nul = -11,
-    lex_element_short = -12,
-    lex_element_long_end = -13,
-};
-
-typedef enum af_LexicalStatus af_LexicalStatus;
-typedef struct af_Lexical af_Lexical;
-typedef struct af_Syntactic af_Syntactic;
-
-struct af_Parser {
-    struct af_Reader *reader;
-    struct af_Lexical *lexical;
-    struct af_Syntactic *syntactic;
-
-    bool is_error;  // Parser遇到错误
-};
-
-struct af_Lexical {  // 词法匹配器的状态机
-    enum af_LexicalStatus status;
-    size_t last;  // 最后一次词法匹配的有效长度
-    enum af_TokenType token;  // token类型\
-
-    size_t mutli_comment;  // 多行注释嵌套等级
-    bool is_end;
-    bool is_error;
-};
-
-struct af_Syntactic {
-    bool back;
-    enum af_TokenType token;
-    char *text;
-};
-
-/* Parser 相关操作 */
-AFUN_CORE_EXPORT af_TokenType getTokenFromLexical(char **text, af_Parser *parser);
-
-#endif //AFUN_PARSER_H_

src/core/__reader.hpp

@@ -1,50 +0,0 @@
-#ifndef AFUN_READER_H_
-#define AFUN_READER_H_
-#include <stdio.h>
-#include "aFunCoreExport.h"  // reader.h 不包含 aFunCoreExport.h
-#include "tool.hpp"
-#include "reader.hpp"
-
-#define DEFAULT_BUF_SIZE (1024)
-#define NEW_BUF_SIZE (512)
-
-typedef struct af_Reader af_Reader;
-
-typedef size_t readerFunc(void *data, char *dest, size_t len, int *mode);
-NEW_DLC_SYMBOL(readerFunc, readerFunc);
-
-typedef void destructReaderFunc(void *data);
-NEW_DLC_SYMBOL(destructReaderFunc, destructReaderFunc);
-
-struct af_Reader {
-    DLC_SYMBOL(readerFunc) read_func;
-    DLC_SYMBOL(destructReaderFunc) destruct;
-    void *data;
-    size_t data_size;
-
-    char *buf;
-    size_t buf_size;  // buf的长度-1
-    char *read;
-    bool read_end;
-    bool read_error;
-    FileLine line;
-    FilePath file;
-
-    bool init;  // 是否初始化
-};
-
-/* Reader 创建与释放 */
-AFUN_CORE_NO_EXPORT af_Reader *makeReader(FileLine line, ConstFilePath file,
-                                          DLC_SYMBOL(readerFunc) read_func, DLC_SYMBOL(destructReaderFunc) destruct_func,
-                                          size_t data_size);
-AFUN_CORE_NO_EXPORT void freeReader(af_Reader *reader);
-
-/* Reader 初始化函数 */
-AFUN_CORE_NO_EXPORT af_Reader *initReader(af_Reader *reader);
-
-/* Reader 操作哈桑 */
-AFUN_CORE_NO_EXPORT char *readWord(size_t del_index, af_Reader *reader);
-AFUN_CORE_NO_EXPORT char getChar(af_Reader *reader);
-AFUN_CORE_NO_EXPORT void *getReaderData(af_Reader *reader);
-
-#endif //AFUN_READER_H_

src/core/__run.hpp

@@ -1,7 +0,0 @@
-#ifndef AFUN_RUN_H_
-#define AFUN_RUN_H_
-#include "run.hpp"
-
-AFUN_CORE_NO_EXPORT bool iterDestruct(int deep, af_Environment *env);
-
-#endif //AFUN_RUN_H_

src/core/__sig.hpp

@@ -1,5 +0,0 @@
-#ifndef AFUN_SIG_H_
-#define AFUN_SIG_H_
-#include <csignal>
-#include "sig.hpp"
-#endif //AFUN_SIG_H_

src/core/__var.hpp

@@ -1,57 +0,0 @@
-#ifndef AFUN_VAR_H_
-#define AFUN_VAR_H_
-#include "macro.hpp"
-#include "pthread.h"
-
-// 这些typedef可能会被下面include的文件使用
-typedef struct af_VarNode af_VarNode;
-typedef struct af_VarCup af_VarCup;
-
-#include "var.hpp"
-#include "__gc.hpp"
-
-#define VAR_HASHTABLE_SIZE (8)
-
-struct af_VarNode {
-    char *id;  // 变量存储值的id为nullptr
-    struct af_Object *obj;
-    struct af_VarNode *next;
-};
-
-struct af_Var {
-    char *name;
-    struct af_VarNode *vn;
-    char permissions[3];  // 读-1 写-2 读且写-3 不读不写-0 [自身权限 后代权限 外部权限]
-    pthread_rwlock_t lock;  // 保护上面三个字段
-
-    GC_Var gc;
-};
-
-struct af_VarCup {
-    struct af_Var *var;
-    struct af_VarCup *next;
-};
-
-struct af_VarSpace {
-    bool is_protect;  // 是否为保护变量空间 (对VarSpaceList的操作都跳过保护空间)
-    struct af_VarCup *(var[VAR_HASHTABLE_SIZE]);
-    struct af_Object *belong;  // 属主
-    char permissions[3];  // 可定义（2），可删除（1） [自身权限 后代权限 外部权限]
-    pthread_rwlock_t lock;  // 控制 除gc外其他字段的访问
-
-    GC_VarSpace gc;  // 仅能由 gc 机制访问
-};
-
-struct af_VarList {  // 变量链
-    struct af_VarSpace *vs;
-    struct af_VarList *next;
-};
-
-
-/* 变量空间创建与释放 */
-AFUN_CORE_NO_EXPORT void freeVarSpace(af_VarSpace *vs, af_Environment *env);
-
-/* 变量创建与释放 */
-AFUN_CORE_NO_EXPORT void freeVar(af_Var *var, af_Environment *env);
-
-#endif //AFUN_VAR_H_

src/core/bytecode.cpp

@@ -1,114 +0,0 @@
-#include "aFunCore.hpp"
-#include "tool.hpp"
-
-#define HEAD "aFun-BytecodeFile"
-#define Done(write) do{if(!(write)){re = 0; goto RETURN_;}}while(0)
-
-/* aFun在一般情况下, 主版本号向下兼容 */
-static bool checkVersion(uint32_t major, uint32_t minor, uint32_t patch) {
-    if (major <= aFunMajorVersion)
-        return true;
-    return false;
-}
-
-char const * const writeByteCodeError[5] = {
-        "File write error.",  // 0
-        nullptr,  // 无错误
-        "File open error.",  // 2
-        "Code md5 error.",  // 3
-        "Write code error."  // 4
-};
-
-char const * const readByteCodeError[7] = {
-        "File read error.",  // 0
-        nullptr,  // 无错误
-        "File open error.",  // 2
-        "The file is not an aFun Bytecode file.",  // 3
-        "Incompatible version.",  // 4
-        "Read code error.",  // 5
-        "Code is broken."  // 6
-};
-
-int writeByteCode(af_Code *code, ConstFilePath path) {
-    if (code == nullptr || path == nullptr)
-        return 0;
-
-    char *md5 = getCodeMD5(code);
-    if (md5 == nullptr)
-        return 3;
-
-    int re = 1;
-    FILE *file = fileOpen(path, "wb");
-    if (file == nullptr) {
-        re = 2;
-        goto RETURN_2;
-    }
-
-    Done(byteWriteStr(file, HEAD));
-    Done(byteWriteUint_32(file, aFunMajorVersion));
-    Done(byteWriteUint_32(file, aFunMinorVersion));
-    Done(byteWriteUint_32(file, aFunPatchVersion));
-    Done(byteWriteStr(file, md5));
-    if (!writeAllCode(code, file)) {
-        re = 4;
-        goto RETURN_;
-    }
-
-RETURN_:
-    fileClose(file);
-RETURN_2:
-    free(md5);
-    return re;
-}
-
-int readByteCode(af_Code **code, ConstFilePath path) {
-    if (code == nullptr || path == nullptr || *code != nullptr)
-        return 0;
-
-    int re = 1;
-    FILE *file = fileOpen(path, "rb");
-    if (file == nullptr)
-        return 2;
-
-    char *head = nullptr;
-    uint32_t major = 0;
-    uint32_t minor = 0;
-    uint32_t patch = 0;
-    char *md5str = nullptr;
-    char *code_md5 = nullptr;
-
-    Done(byteReadStr(file, &head));
-    if (!EQ_STR(head, HEAD)) {
-        re = 3;
-        goto RETURN_;
-    }
-
-    Done(byteReadUint_32(file, &major));
-    Done(byteReadUint_32(file, &minor));
-    Done(byteReadUint_32(file, &patch));
-    Done(byteReadStr(file, &md5str));
-
-    if (!checkVersion(major, minor, patch)) {
-        re = 4;
-        goto RETURN_;
-    }
-
-    if (!readAllCode(code, path, file)) {
-        re = 5;
-        goto RETURN_;
-    }
-
-    code_md5 = getCodeMD5(*code);
-    if (code_md5 == nullptr || !EQ_STR(code_md5, md5str)) {
-        re = 6;
-        freeAllCode(*code);
-        goto RETURN_;
-    }
-
-RETURN_:
-    free(head);
-    free(md5str);
-    free(code_md5);
-    fileClose(file);
-    return re;
-}

src/core/code.cpp

@@ -1,605 +0,0 @@
-/*
- * 文件名: code.c
- * 目标: 管理Code结构体的函数
- */
-
-#include <cstdio>
-#include <cctype>
-#include "aFunCore.hpp"
-#include "tool.hpp"
-#include "__code.hpp"
-
-/* Code 创建函数 */
-static af_Code *makeCode(char prefix, FileLine line, ConstFilePath path);
-static af_Code *freeCode(af_Code *bt);
-
-/* Code 相关操作 */
-static int countElement(af_Code *element, CodeUInt *elements, af_Code **next);
-
-/* Code IO函数 */
-static bool readCode(af_Code **bt, af_Code *prev, FILE *file);
-static bool writeCode(af_Code *bt, FILE *file);
-
-/* Code 转换STR函数 */
-struct af_BlockEnd {
-    char ch;
-    struct af_BlockEnd *next;
-};
-static bool checkElementData(char *data);
-static char *codeToStr_(af_Code *code, LayerInt *layer, struct af_BlockEnd **bn);
-static char *codeEndToStr(CodeUInt code_end, LayerInt *layer, struct af_BlockEnd **bn);
-
-static af_Code *makeCode(char prefix, FileLine line, ConstFilePath path) {
-    auto bt = calloc(1, af_Code);
-    bt->line = line;
-    bt->prefix = prefix;
-    if (path != nullptr)
-        bt->path = strCopy(path);
-    return bt;
-}
-
-af_Code *makeElementCode(const char *var, char prefix, FileLine line, ConstFilePath path) {
-    if (prefix != NUL && strchr(E_PREFIX, prefix) == nullptr)
-        prefix = NUL;
-
-    if (!isCharUTF8(var))
-        return nullptr;
-
-    af_Code *bt = makeCode(prefix, line, path);
-    bt->type = code_element;
-    bt->element.data = strCopy(var);
-    return bt;
-}
-
-/* 判断该code是否令layer需要加1 */
-/* 即判定是否有子元素 */
-#define LAYER_ADD1(code) ((code)->type == code_block && !(code)->block.is_empty)
-
-/*
- * 函数名: countElement
- * 目标: 统计元素个数（不包括元素的子元素
- * 返回1 表示没有跳出过多层级
- * 返回2 表示跳出了过多层级
- * 返回0 表示错误
- */
-static int countElement(af_Code *element, CodeUInt *elements, af_Code **next) {
-    CodeUInt layer = 0;  // layer 是相对于当前element的层级数, 可能为负数
-    af_Code *tmp = nullptr;
-    if (next == nullptr)
-        next = &tmp;
-
-    for (*elements = 0; element != nullptr; *next = element, element = element->next) {
-        if (layer == 0)
-            (*elements)++;
-
-        if (LAYER_ADD1(element))
-            layer++;
-
-        if (layer - element->code_end < 0)
-            return 2;
-        else
-            layer = layer - element->code_end;
-    }
-
-    if (layer == 0)
-        return 1;
-    else  // 大于0, 出现错误
-        return 0;
-}
-
-af_Code *makeBlockCode(enum af_BlockType type, af_Code *element, char prefix, FileLine line, ConstFilePath path, af_Code **next) {
-    af_Code *tmp = nullptr;  // 保存最后一个code的地址
-    CodeUInt elements = 0;
-
-    if (next == nullptr)
-        next = &tmp;
-
-    if (prefix != NUL && strchr(B_PREFIX, prefix) == nullptr)
-        prefix = NUL;
-
-    if (countElement(element, &elements, next) != 1)
-        return nullptr;
-
-    af_Code *bt = makeCode(prefix, line, path);
-    bt->type = code_block;
-    bt->block.type = type;
-    bt->next = element;
-    if (elements == 0)
-        bt->block.is_empty = true;
-    else
-        (*next)->code_end++;  // 若 elements 不为 0, 则next指向最后一个元素
-    return bt;
-}
-
-af_Code *pushCode(af_Code **base, af_Code *next) {
-    af_Code *prev = nullptr;
-    while ((*base) != nullptr) {
-        prev = *base;
-        base = &(prev->next);
-    }
-    next->prev = prev;
-    *base = next;
-
-    while (next != nullptr && next->next != nullptr)
-        next = next->next;
-
-    return next;
-}
-
-af_Code *copyAllCode(af_Code *base, ConstFilePath path) {
-    af_Code *dest = nullptr;
-    af_Code **pdest = &dest;
-    af_Code *prev = nullptr;
-
-    for(NULL; base != nullptr; base = base->next, prev = *pdest, pdest = &(prev->next)) {
-        *pdest = makeCode(base->prefix, base->line, base->path);
-        (*pdest)->type = base->type;
-        (*pdest)->code_end = base->code_end;
-        (*pdest)->prev = prev;
-
-        switch (base->type) {
-            case code_element:
-                (*pdest)->element.data = strCopy(base->element.data);
-                break;
-            case code_block:
-                (*pdest)->block.is_empty = base->block.is_empty;
-                (*pdest)->block.type = base->block.type;
-                break;
-            default:
-                break;
-        }
-    }
-
-    if (dest != nullptr && path != nullptr) {
-        free(dest->path);
-        dest->path = strCopy(path);
-    }
-
-    return dest;
-}
-
-/*
- * 函数名: copyCode
- * 目标: 拷贝 code, 并为末尾的code设置合适的code_end
- */
-af_Code *copyCode(af_Code *base){
-    af_Code *dest = nullptr;
-    af_Code **pdest = &dest;
-    af_Code *prev = nullptr;
-
-    CodeUInt layer = 0;
-    for(NULL; base != nullptr; base = base->next, prev = *pdest, pdest = &(prev->next)) {
-        *pdest = makeCode(base->prefix, base->line, base->path);
-        (*pdest)->type = base->type;
-        (*pdest)->prev = prev;
-
-        switch (base->type) {
-            case code_element:
-                (*pdest)->element.data = strCopy(base->element.data);
-                break;
-            case code_block:
-                (*pdest)->block.is_empty = base->block.is_empty;
-                (*pdest)->block.type = base->block.type;
-                break;
-            default:
-                break;
-        }
-
-        if (LAYER_ADD1(base))
-            layer++;
-
-        if ((layer - base->code_end) < 0) {  // base跳出layer, pdest不能按照base的code_end来, pdest只能刚好跳出layer
-            (*pdest)->code_end = layer;
-            break;
-        } else {  // 仍没跳出 layer
-            (*pdest)->code_end = base->code_end;
-            layer -= base->code_end;
-        }
-    }
-    return dest;
-}
-
-static af_Code *freeCode(af_Code *bt) {
-    af_Code *next = bt->next;
-    free(bt->path);
-    switch (bt->type) {
-        case code_element:
-            free(bt->element.data);
-            break;
-        default:
-            break;
-    }
-
-    free(bt);
-    return next;
-}
-
-void freeAllCode(af_Code *bt) {
-    while (bt != nullptr)
-        bt = freeCode(bt);
-}
-
-af_Code *getCodeNext(af_Code *bt) {
-    if (!LAYER_ADD1(bt))
-        return bt->code_end == 0 ? bt->next : nullptr;
-
-    CodeUInt layer = 1;
-    bt = bt->next;  // 跳过第一个code_block
-    while (bt != nullptr) {
-        if (LAYER_ADD1(bt))
-            layer++;
-        if (layer - bt->code_end == 0)  // layer为0表示迭代到该block的最后一个元素, 则该元素的下一个元素为该block的Next
-            return bt->next;
-        else if (layer - bt->code_end < 0)  // 当layer小于0时, 认为已经无next, 即连续跳出了多层
-            return nullptr;
-        layer = layer - bt->code_end;
-        bt = bt->next;
-    }
-
-    return nullptr;
-}
-
-af_Code *getCodeElement(af_Code *bt) {
-    if (!LAYER_ADD1(bt))
-        return nullptr;
-    return bt->next;
-}
-
-#define Done(write) do{if(!(write)){return false;}}while(0)
-static bool writeCode(af_Code *bt, FILE *file) {
-    Done(byteWriteUint_8(file, bt->type));
-    Done(byteWriteUint_8(file, bt->prefix));
-    Done(byteWriteUint_32(file, bt->line));
-    Done(byteWriteUint_32(file, bt->code_end));
-
-    switch (bt->type) {
-        case code_element:
-            Done(byteWriteStr(file, bt->element.data));
-            break;
-        case code_block:
-            Done(byteWriteUint_8(file, bt->block.type));
-            Done(byteWriteUint_8(file, bt->block.is_empty));
-            break;
-        default:
-            break;
-    }
-    return true;
-}
-
-/*
- * 函数名: writeAllCode
- * 目标: 将Code写入字节码文件中
- * 备注: 写入字节码时不做语义检查, 在读取时最语义检查即可
- */
-bool writeAllCode(af_Code *bt, FILE *file) {
-    if (bt == nullptr || bt->path == nullptr)
-        return false;
-
-    if (!codeSemanticCheck(bt))
-        goto RETURN_FALSE;
-
-    for(NULL; bt != nullptr; bt = bt->next) {
-        if (!writeCode(bt, file))
-            goto RETURN_FALSE;
-
-        if (CLEAR_FERROR(stdin))
-            goto RETURN_FALSE;
-
-        Done(byteWriteUint_8(file, (bt->next == nullptr)));  // 记录是否为最后一位
-    }
-
-    return true;
-
-RETURN_FALSE:
-    return false;
-}
-
-static bool readCode(af_Code **bt, af_Code *prev, FILE *file) {
-    uint8_t type;
-    uint8_t prefix;
-    uint32_t line;
-    uint32_t code_end;
-
-    Done(byteReadUint_8(file, &type));
-    Done(byteReadUint_8(file, &prefix));
-    Done(byteReadUint_32(file,&line));
-    Done(byteReadUint_32(file, &code_end));
-
-    *bt = makeCode((char)prefix, line, nullptr);
-    (*bt)->type = (enum af_CodeType)type;
-    (*bt)->code_end = (CodeUInt)code_end;
-    (*bt)->prev = prev;
-
-    switch (type) {
-        case code_element:
-            Done(byteReadStr(file, &((*bt)->element.data)));
-            break;
-        case code_block: {
-            uint8_t block_type;
-            uint8_t is_empty;
-            Done(byteReadUint_8(file, &block_type));
-            Done(byteReadUint_8(file,&is_empty));
-            (*bt)->block.type = (enum af_BlockType)block_type;
-            (*bt)->block.is_empty = (CodeUInt)is_empty;
-            break;
-        }
-        default:
-            break;
-    }
-    return true;
-}
-
-bool readAllCode(af_Code **bt, ConstFilePath path, FILE *file) {
-    af_Code **base = bt;
-    af_Code *prev = nullptr;
-    *bt = nullptr;
-
-    for(NULL; true;prev = *bt, bt = &(prev->next)) {
-        if(!readCode(bt, prev, file))
-            goto RETURN_FALSE;
-        if (CLEAR_FERROR(stdin))
-            goto RETURN_FALSE;
-
-        uint8_t last;
-        Done(byteReadUint_8(file, &last));
-        if (last)
-            break;
-    }
-
-    if (*base != nullptr && path != nullptr)
-        (*base)->path = strCopy(path);
-
-    if (!codeSemanticCheck(*base))
-        goto RETURN_FALSE;
-    return true;
-
-RETURN_FALSE:
-    freeAllCode(*bt);
-    *bt = nullptr;
-    return false;
-}
-
-/*
- * 函数名: checkElementData
- * 目标: 检查element中data字符串是否有空白符
- */
-static bool checkElementData(char *data) {
-    for (char *ch = data; *ch != NUL; ch++) {
-        if (isspace(*ch) || *ch == '\n')
-            return true;
-    }
-    return false;
-}
-
-/*
- * 函数名: codeEndToStr
- * 目标: 转换element或开括号为字符串
- * 若遇到开括号则设定bn, 并且设定layer
- *
- * bn中记录了开括号的顺序, 再打印闭括号时将按该顺序打印
- */
-static char *codeToStr_(af_Code *code, LayerInt *layer, struct af_BlockEnd **bn) {
-    char *re = charToStr(code->prefix);
-    if (code->type == code_element) {
-        if (checkElementData(code->element.data)) {  // 需要|xx xx|语法
-            re = strJoin(re, "|", true, false);
-            re = strJoin(re, code->element.data, true, false);
-            re = strJoin(re, "| ", true, false);
-        } else
-            re = strJoin(re, code->element.data, true, false);
-    } else if (code->block.is_empty) {
-        switch(code->block.type) {
-            case parentheses:
-                re = strJoin(re, "()", true, false);
-                break;
-            case brackets:
-                re = strJoin(re, "[]", true, false);
-                break;
-            case curly:
-                re = strJoin(re, "{}", true, false);
-                break;
-            default:
-                break;
-        }
-    } else {
-        char ch = NUL;
-        switch(code->block.type) {
-            case parentheses:
-                re = strJoin(re, "(", true, false);
-                ch = ')';
-                break;
-            case brackets:
-                re = strJoin(re, "[", true, false);
-                ch = ']';
-                break;
-            case curly:
-                re = strJoin(re, "{", true, false);
-                ch = '}';
-                break;
-            default:
-                break;
-        }
-        auto new_bn = calloc(1, struct af_BlockEnd);
-        new_bn->ch = ch;
-        new_bn->next = *bn;
-        *bn = new_bn;
-        (*layer)++;
-    }
-    return re;
-}
-
-/*
- * 函数名: codeEndToStr
- * 目标: 转换闭括号为字符串
- */
-static char *codeEndToStr(CodeUInt code_end, LayerInt *layer, struct af_BlockEnd **bn) {
-    char *re = NEW_STR(code_end);
-    for (size_t i = 0; code_end > 0; code_end--, i++) {
-        if (*bn == nullptr)
-            break;
-        (*layer)--;
-        re[i] = (*bn)->ch;
-
-        struct af_BlockEnd *tmp = (*bn)->next;
-        free(*bn);
-        *bn = tmp;
-    }
-    re = strJoin(re, " ", true, false);
-    return re;
-}
-
-/*
- * 函数名: codeToStr
- * 目标: 转换n个元素(或n个函数调用)为code
- */
-char *codeToStr(af_Code *code, int n) {
-    char *re = strCopy(nullptr);
-    struct af_BlockEnd *bn = nullptr;
-    LayerInt layer = 0;
-
-    for(NULL; code != nullptr && layer >= 0 && (n > 0 || n == -1); code = code->next) {
-        if (strlen(re) >= CODE_STR_MAX_SIZE) {
-            re = strJoin(re, " ...", true, false);  // 限度
-            break;
-        }
-
-        re = strJoin(re, codeToStr_(code, &layer, &bn), true, true);
-        if (code->code_end != 0)
-            re = strJoin(re, codeEndToStr(code->code_end, &layer, &bn), true, true);
-        if (n != -1 && layer == 0) /* 完成一个元素的打印 */
-            n--;
-    }
-    return re;
-}
-
-static void printLayerSpace(size_t layer) {
-    for (size_t i = 0; i < layer; i++)
-        fputs("    ", stdout);
-}
-
-void printCode(af_Code *bt) {
-    size_t layer = 0;
-    for(NULL; bt != nullptr || layer < 0; bt = bt->next) {
-        printLayerSpace(layer);
-        layer = layer - bt->code_end;
-        switch (bt->type) {
-            case code_element:
-                printf("element: [prefix (%c)] [end %u] [data '%s']\n", bt->prefix, bt->code_end, bt->element.data);
-                break;
-            case code_block:
-                if (LAYER_ADD1(bt))
-                    layer++;
-                printf("code: [prefix (%c)] [end %u] [type %c] [empty %d]\n", bt->prefix, bt->code_end, bt->block.type, bt->block.is_empty);
-                break;
-            default:
-                printf("Unknown: [prefix (%c)] [end %u] [type %d]\n", bt->prefix, bt->code_end, bt->type);
-                break;
-        }
-    }
-}
-
-enum af_CodeType getCodeType(af_Code *code) {
-    return code->type;
-}
-
-enum af_BlockType getCodeBlockType(af_Code *code) {
-    if (code->type != code_block)
-        return (enum af_BlockType)'(';
-    return code->block.type;
-}
-
-char getCodePrefix(af_Code *code) {
-    return code->prefix;
-}
-
-CodeUInt getCodeEndCount(af_Code *code) {
-    return code->code_end;
-}
-
-char *getCodeElementData(af_Code *code) {
-    if (code->type != code_element)
-        return nullptr;
-    return code->element.data;
-}
-
-CodeUInt getCodeElementCount(af_Code *code) {
-    if (!LAYER_ADD1(code))
-        return 0;
-
-    CodeUInt count;
-    if (countElement(code->next, &count, nullptr) == 0)
-        return 0;
-    return count;
-}
-
-char *getCodeMD5(af_Code *code) {
-    char *md5str = calloc(MD5_STR_LEN + 1, char);
-    char md5_value[MD5_SIZE];
-    MD5_CTX *md5 = MD5Init();
-
-    for(NULL; code != nullptr; code = code->next) {
-        char *tmp = nullptr;
-        char head[] = {(char)code->type, code->prefix, 'x', 'x', NUL};
-        char tail[512] = {0};
-
-        if (code->prefix == NUL)
-            head[1] = '-';
-        if (code->type == code_block) {
-            head[2] = code->block.is_empty ? 'e' : 'n';
-            head[3] = code->block.type;
-        } else
-            tmp = strCopy(code->element.data);
-        snprintf(tail, 512, "%d:%d", code->code_end, code->line);
-        tmp = strJoin(head, tmp, false, true);
-        tmp = strJoin(tmp, tail, true, false);
-
-        MD5Update(md5, (unsigned char *)tmp, strlen((char *)tmp));
-        free(tmp);
-    }
-
-    MD5Final(md5, (unsigned char *)md5_value);
-
-    for(int i = 0; i < MD5_SIZE; i++)
-        snprintf((char *)md5str + i * 2, 2 + 1, "%02x", md5_value[i]);
-    return md5str;
-}
-
-static bool codeElementCheck(char *data) {
-    if (data == nullptr)
-        return false;
-
-    return isCharUTF8(data);
-}
-
-/*
- * 函数名: codeSemanticCheck
- * 目标: 检查code结构体是否符合语义
- */
-bool codeSemanticCheck(af_Code *code) {
-    CodeUInt layer = 0;
-    if (code == nullptr || code->path == nullptr)
-        return false;
-
-    for(NULL; code != nullptr; code = code->next) {
-        if (code->type != code_block && code->type != code_element)
-            return false;
-        if (code->type == code_element && !codeElementCheck(code->element.data))
-            return false;
-        if (code->type == code_block) {
-            if (code->block.type != parentheses &&
-                code->block.type != brackets && code->block.type != curly)
-                return false;
-            if (!code->block.is_empty && code->code_end != 0)  // 正常情况下, block的code_end为0, 但empty时除外
-                return false;
-        }
-        if (code->prefix != NUL && !strchr(ALL_PREFIX, code->prefix))
-            return false;
-        if (LAYER_ADD1(code))
-            layer++;
-        if (layer - code->code_end < 0)
-            return false;
-        layer -= code->code_end;
-    }
-
-    return true;
-}

src/core/core_init.cpp

@@ -1,94 +0,0 @@
-/*
- * 文件名: core_init.c
- * 目标: 初始化函数
- */
-
-#include <clocale>
-#include "core_init.hpp"
-#include "__sig.hpp"
-#include "tool.hpp"
-
-static Logger aFunCoreLogger_;
-Logger *aFunCoreLogger = &aFunCoreLogger_;
-
-char *log_path = nullptr;
-char *lang_path = nullptr;
-char *varlib_path = nullptr;
-
-static void destructCoreExit(void *data) {
-    free(log_path);
-    free(lang_path);
-    free(varlib_path);
-}
-
-bool aFunCoreInit(aFunCoreInitInfo *info) {
-    if (info == nullptr) {
-        static aFunCoreInitInfo info_default = {.base_dir=".",
-                                                .log_asyn=true,
-                                                .buf=nullptr,
-                                                .level=log_info};
-        info = &info_default;
-    }
-
-    getEndian();
-    if (setlocale(LC_ALL, "") == nullptr)
-        return false;
-    if (info->base_dir == nullptr)
-        return false;
-
-    log_path = strJoin(info->base_dir, SEP aFunLogDir SEP, false, false);
-    lang_path = strJoin(info->base_dir, SEP aFunLangDir SEP, false, false);
-    varlib_path = strJoin(info->base_dir, SEP aFunVarLibDir SEP, false, false);
-    aFunAtExit(destructCoreExit, nullptr);
-
-    char *log = strJoin(log_path, "aFunlang", false, false);
-    bool re = initLogSystem(log, info->log_asyn);
-    free(log);
-    if (re == 0)
-        return false;
-
-    initLogger(aFunCoreLogger, "aFunlang-core", info->level);
-    aFunCoreLogger->buf = info->buf;
-
-    writeDebugLog(aFunCoreLogger, "aFunCore log path: %s", log_path);
-    writeDebugLog(aFunCoreLogger, "aFunCore var.lib path: %s", varlib_path);
-    writeDebugLog(aFunCoreLogger, "aFunCore lang path: %s", lang_path);
-
-    char LANG_path[218] = {0};
-    snprintf(LANG_path, 218, "%sLANG", lang_path);
-
-    FILE *LANG_file = fileOpen(LANG_path, "r");
-    if (LANG_file != nullptr) {
-        char LANG[100] = {0};
-        fgets(LANG, 100, LANG_file);
-        if (LANG[strlen(LANG) - 1] == '\n')
-            LANG[strlen(LANG) - 1] = NUL;  // 去除`\n`
-        writeDebugLog(aFunCoreLogger, "language = %s", LANG);
-
-        char LANG_lib[218] = {0};
-        snprintf(LANG_lib, 218, "%s" SHARED_PREFIX "%s" SHARED_SUFFIX, lang_path, LANG);
-        if (HT_initaFunGetText(LANG_lib) == 0)
-            writeDebugLog(aFunCoreLogger, "aFunCore lang init success: %s", LANG_lib);
-        else
-            writeDebugLog(aFunCoreLogger, "aFunCore lang init failed: %s", LANG_lib);
-        fileClose(LANG_file);
-    } else
-        HT_initaFunGetText(nullptr);
-    writeDebugLog(aFunCoreLogger, "aFunCore init success");
-    return true;
-}
-
-bool aFunCoreDestruct() {
-    destructLogSystem();
-    return true;
-}
-
-void defineRunEnvCore(aFunRunCoreInfo *run_env) {
-    if (run_env->signal)
-        aFunSignalInit();
-}
-
-void undefRunEnvCore(aFunRunCoreInfo *run_env) {
-    if (run_env->signal)
-        aFunSignalRecover();
-}

src/core/env.cpp

@@ -1,2243 +0,0 @@
-#include "aFunCore.hpp"
-#include "__env.hpp"
-#include "__global_obj.hpp"
-#include "__run.hpp"
-#include "__sig.hpp"
-#include "obj_api.h"
-
-/* Activity 创建和释放 */
-static af_Activity *makeActivity(af_Message *msg_up, af_VarList *varlist, af_Object *belong, af_Environment *env);
-static af_Activity *makeFuncActivity(af_Code *bt_top, af_Code *bt_start, bool return_first, af_Message *msg_up,
-                                     af_VarList *out_varlist, af_Object *belong, af_Object *func,
-                                     af_Environment *env);
-static af_Activity * makeTopActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong,
-                                     af_Environment *env);
-static af_Activity *makeTopImportActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong,
-                                          const char *mark, af_Environment *env);
-static af_Activity *makeGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env);
-static af_Activity *freeActivity(af_Activity *activity, af_Environment *env);
-static void freeActivityTop(af_Activity *activity);
-static void freeAllActivity(af_Activity *activity, af_Environment *env);
-
-/* Activity 相关处理函数 */
-static void clearFuncActivity(af_Activity *activity);
-static void pushActivity(af_Activity *activity, af_Environment *env);
-static void freeMark(af_Activity *activity);
-static void newFuncActivity(af_Code *bt, const af_Code *next, bool return_first, af_Environment *env);
-
-/* ActivityTrackBack 创建与释放 */
-static af_ActivityTrackBack *makeActivityTrackBack(af_Activity *activity);
-static af_ActivityTrackBack *freeActivityTrackBack(af_ActivityTrackBack *atb);
-static void freeAllActivityTrackBack(af_ActivityTrackBack *atb);
-
-/* 环境变量 创建与释放 */
-static af_EnvVar *makeEnvVar(const char *name);
-static af_EnvVar *freeEnvVar(af_EnvVar *var);
-static void freeAllEnvVar(af_EnvVar *var);
-static void freeEnvVarSpace(af_EnvVarSpace *evs);
-
-/* 顶层消息处理器 创建与释放 */
-static af_TopMsgProcess *makeTopMsgProcess(const char *type, DLC_SYMBOL(TopMsgProcessFunc) func);
-static af_TopMsgProcess *freeTopMsgProcess(af_TopMsgProcess *mp);
-static void freeAllTopMsgProcess(af_TopMsgProcess *mp);
-
-/* 顶层消息处理器 处理函数 */
-static af_TopMsgProcess *findTopMsgProcessFunc(const char *type, af_Environment *env);
-
-/* 守护器 创建与释放 */
-static af_Guardian *makeGuardian(const char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
-                                 DLC_SYMBOL(GuardianDestruct) destruct);
-static af_Guardian *freeGuardian(af_Guardian *gd, af_Environment *env);
-static void freeAllGuardian(af_Guardian *gd, af_Environment *env);
-
-/* 守护器 处理函数 */
-static af_Guardian *findGuardian(const char *type, af_Environment *env);
-
-/* LiteralData 创建与释放 */
-static af_LiteralDataList *makeLiteralDataList(char *data);
-static af_LiteralDataList *freeLiteralData_Pri(af_LiteralDataList *ld);
-
-/* LiteralRegex 创建与释放 */
-static af_LiteralRegex *makeLiteralRegex(const char *pattern, const char *func, bool in_protect);
-static af_LiteralRegex *freeLiteralRegex(af_LiteralRegex *lr);
-static void freeAllLiteralRegex(af_LiteralRegex *lr);
-
-/* EnvironmentList 创建与释放 */
-static af_EnvironmentList *makeEnvironmentList(af_Environment *env);
-static bool freeEnvironmentList(af_EnvironmentList *envl, af_Environment *base);
-
-/* af_ErrorBacktracking 创建与释放 */
-static af_ErrorBacktracking *makeErrorBacktracking(FileLine line, FilePath file, const char *note);
-static af_ErrorBacktracking *freeErrorBacktracking(af_ErrorBacktracking *ebt);
-static void freeAllErrorBacktracking(af_ErrorBacktracking *ebt);
-
-/* af_ErrorBacktracking 相关函数 */
-static char *getActivityInfoToBacktracking(af_Activity *activity);
-static char *getActivityTrackBackInfoToBacktracking(af_ActivityTrackBack *atb);
-static void fprintfNote(FILE *file, const char *note);
-static void fprintfNoteStderr(const char *note);
-static void fprintfNoteStdout(const char *note);
-
-/* af_GuardianList 创建与释放 */
-static af_GuardianList *makeGuardianList(af_Object *obj, af_Object *func, af_Environment *env);
-static af_GuardianList *freeGuardianList(af_GuardianList *gl, af_Environment *env);
-static void freeAllGuardianList(af_GuardianList *gl, af_Environment *env);
-
-/* 内置顶层消息处理器 */
-static void mp_NORMAL(af_Message *msg, bool is_top, af_Environment *env);
-static void mp_ERROR(af_Message *msg, bool is_top, af_Environment *env);
-static void mp_IMPORT(af_Message *msg, bool is_top, af_Environment *env);
-static void mp_NORMALThread(af_Message *msg, bool is_top, af_Environment *env);
-
-/* 变量检查函数 */
-static bool isInfixFunc(af_Code *code, af_Environment *env);
-
-char setPrefix(size_t name, char prefix, af_Environment *env) {
-    if (name >= PREFIX_SIZE)
-        return '-';  // 表示未获取到prefix (NUL在Code中表示无prefix)
-
-    pthread_rwlock_wrlock(&env->esv->lock);
-    char *prefix_ = env->prefix->data;
-    if (prefix_ == nullptr || strlen(prefix_) < PREFIX_SIZE) {
-        pthread_rwlock_unlock(&env->esv->lock);
-        return '-';
-    }
-
-    switch (name) {
-        case E_QUOTE:
-            if (prefix == NUL && strchr(E_PREFIX, prefix) == nullptr)
-                prefix = '-';
-            break;
-        case B_EXEC:
-        case B_EXEC_FIRST:
-            if (prefix == NUL && strchr(B_PREFIX, prefix) == nullptr)
-                prefix = '-';
-            break;
-        default:
-            break;
-    }
-    char old = prefix_[name];
-    prefix_[name] = prefix;
-    pthread_rwlock_unlock(&env->esv->lock);
-    return old;
-}
-
-char getPrefix(size_t name, af_Environment *env) {
-    if (name >= PREFIX_SIZE)
-        return '-';  // 表示未获取到prefix (NUL在Code中表示无prefix)
-
-    pthread_rwlock_rdlock(&env->esv->lock);
-    char *prefix = env->prefix->data;
-    pthread_rwlock_unlock(&env->esv->lock);
-    if (prefix == nullptr || strlen(prefix) < PREFIX_SIZE)
-        return '-';
-    return prefix[name];
-}
-
-af_VarSpace *getProtectVarSpace(af_Environment *env) {
-    return env->protect;
-}
-
-
-/*
- * 函数名: getBaseObject
- * 目标: getBaseObjectFromCore的对外接口
- */
-af_Object *getBaseObject(const char *name, af_Environment *env) {
-    af_Var *var = findVarFromVarSpace(name, nullptr, env->protect);
-    if (var != nullptr)
-        return findVarNode(var, nullptr, env);
-    return nullptr;
-}
-
-void setCoreStop(af_Environment *env) {
-    pthread_mutex_lock(&env->status_lock);
-    if (env->status != core_exit)
-        env->status = core_stop;
-    pthread_mutex_unlock(&env->status_lock);
-}
-
-void setCoreExit(int exit_code, af_Environment *env) {
-    pthread_rwlock_wrlock(&env->esv->lock);
-    env->exit_code_->num = exit_code;
-    pthread_rwlock_unlock(&env->esv->lock);
-
-    setCoreExitNotExitCode(env);
-}
-
-void setCoreExitNotExitCode(af_Environment *env) {
-    pthread_mutex_lock(&env->status_lock);
-    env->status = core_exit;
-    pthread_mutex_unlock(&env->status_lock);
-
-    if (!env->is_derive) {  // 若是主线程, 通知所有次线程
-        pthread_mutex_lock(&env->thread_lock);
-        for (af_EnvironmentList *envl = env->env_list; envl != nullptr; envl = envl->next) {
-            pthread_mutex_lock(&envl->env->thread_lock);
-            if (envl->env->monitor != nullptr)
-                pthread_cond_signal(&envl->env->monitor->cond);
-            pthread_mutex_unlock(&envl->env->thread_lock);
-        }
-        pthread_mutex_unlock(&env->thread_lock);
-    }
-}
-
-void setCoreNormal(af_Environment *env) {
-    pthread_mutex_lock(&env->status_lock);
-    if (env->status == core_exit || env->status == core_stop)
-        env->status = core_normal;
-    pthread_mutex_unlock(&env->status_lock);
-
-    pthread_rwlock_wrlock(&env->esv->lock);
-    env->exit_code_->num = 0;
-    pthread_rwlock_unlock(&env->esv->lock);
-}
-
-static af_Activity *makeActivity(af_Message *msg_up, af_VarList *varlist, af_Object *belong,
-                                 af_Environment *env){
-    auto activity = calloc(1, af_Activity);
-    activity->msg_up = msg_up;
-    activity->msg_up_count = 0;
-    activity->run_varlist = varlist;
-    activity->count_run_varlist = 0;
-    activity->belong = belong;
-    activity->line = 1;
-    activity->gc_lock = &env->base->gc_factory->mutex;
-    return activity;
-}
-
-static af_Activity *makeFuncActivity(af_Code *bt_top, af_Code *bt_start, bool return_first, af_Message *msg_up,
-                                     af_VarList *out_varlist, af_Object *belong, af_Object *func,
-                                     af_Environment *env){
-    af_Activity *activity = makeActivity(msg_up, out_varlist, belong, env);
-
-    activity->type = act_func;
-    activity->status = act_func_get;
-    activity->func = func;
-
-    activity->out_varlist = out_varlist;
-    activity->func_varlist = nullptr;
-
-    setActivityBtTop(bt_top, activity);  // 非NORMAL期间, bt_top被设定
-    setActivityBtStart(bt_start, activity);
-
-    activity->return_first = return_first;
-    return activity;
-}
-
-static af_Activity *makeTopActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong,
-                                    af_Environment *env){
-    af_Activity *activity = makeActivity(nullptr, nullptr, belong, env);
-
-    activity->type = act_top;
-    activity->status = act_func_normal;
-
-    activity->count_run_varlist = 2;
-    activity->run_varlist = pushVarList(protect, nullptr);
-    activity->run_varlist = pushVarList(getObjectVarSpace(belong), activity->run_varlist);
-
-    setActivityBtTop(nullptr, activity);  // top-activity直接就在normal, bt_top将不被设定
-    setActivityBtStart(bt_start, activity);
-
-    return activity;
-}
-
-static af_Activity *makeTopImportActivity(af_Code *bt_top, af_Code *bt_start, af_VarSpace *protect, af_Object *belong,
-                                          const char *mark,af_Environment *env){
-    af_Activity *activity = makeTopActivity(bt_top, bt_start, protect, belong, env);
-    activity->type = act_top_import;
-    if (mark != nullptr)
-        activity->import_mark = strCopy(mark);
-    return activity;
-}
-
-static af_Activity *makeGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env) {
-    af_Activity *activity = makeActivity(nullptr, nullptr, env->global, env);
-    activity->type = act_guardian;
-
-    activity->run_varlist = pushProtectVarList(nullptr, env);
-    activity->count_run_varlist = 1;
-
-    activity->file = strCopy("guardian.aun.sys");
-    activity->line = 1;
-    activity->gl = gl;
-    activity->pgl = pgl;
-    activity->gl_next = gl;
-    activity->is_guard = true;
-    return activity;
-}
-
-static af_Activity *freeActivity(af_Activity *activity, af_Environment *env){
-    pthread_mutex_lock(activity->gc_lock);
-    af_Activity *prev = activity->prev;
-
-    freeAllMessage(activity->msg_down);  // msg转移后需要将对应成员设置为nullptr
-    freeMessageCount(activity->msg_up_count, activity->msg_up);
-
-    free(activity->file);
-    freeVarSpaceListCount(activity->count_run_varlist, activity->run_varlist);
-
-    if (activity->type == act_guardian) {
-        if (activity->gl != nullptr)
-            freeAllGuardianList(activity->gl, env);
-    } else {
-        freeVarSpaceListCount(activity->count_out_varlist, activity->out_varlist);
-        freeVarSpaceListCount(activity->count_macro_varlist, activity->macro_varlist);
-
-        freeAllArgCodeList(activity->acl_start, env);
-        if (activity->fi != nullptr)
-            freeFuncInfo(activity->fi);
-        freeAllLiteralData(activity->ld);
-
-        freeAllActivityTrackBack(activity->tb);
-        free(activity->import_mark);
-    }
-
-    pthread_mutex_unlock(activity->gc_lock);
-    free(activity);
-    return prev;
-}
-
-static void freeActivityTop(af_Activity *activity) {
-    freeAllMessage(activity->msg_down);  // msg转移后需要将对应成员设置为nullptr
-    freeMessageCount(activity->msg_up_count, activity->msg_up);
-
-    setActivityBtTop(nullptr, activity);
-    setActivityBtStart(nullptr, activity);
-    free(activity->file);
-}
-
-static void freeAllActivity(af_Activity *activity, af_Environment *env){
-    while (activity != nullptr)
-        activity = freeActivity(activity, env);
-}
-
-static void pushActivity(af_Activity *activity, af_Environment *env) {
-    if (env->activity->is_guard)
-        activity->is_guard = true;
-
-    activity->prev = env->activity;
-    env->activity = activity;
-}
-
-/*
- * 函数名: clearActivity
- * 目标: 尾调用优化时用于清理Activity.
- * file和line都遗留
- * 清空 varlist (除 run_varlist)
- */
-static void clearFuncActivity(af_Activity *activity) {
-    /* acl在runArgList之后就被释放了 */
-    /* acl在FuncBody暂时不释放 */
-
-    pthread_mutex_lock(activity->gc_lock);
-    activity->out_varlist = activity->run_varlist;
-    activity->count_out_varlist = activity->count_run_varlist;
-    activity->count_run_varlist = 0;
-
-    activity->macro_varlist = nullptr;
-    activity->count_macro_varlist = 0;
-
-    activity->func_varlist = nullptr;
-
-    /* mark在setFuncActivityToNormal被清理*/
-    /* 只有FuncBody执行到最后一个(意味着Mark被清理)后才会有尾调用优化 */
-    activity->mark = nullptr;
-    activity->func = nullptr;
-    pthread_mutex_unlock(activity->gc_lock);
-
-    setActivityBtTop(nullptr, activity);
-    setActivityBtStart(nullptr, activity);
-
-    /* acl_start 在 setFuncActivityAddVar 时被释放 */
-    activity->acl_start = nullptr;
-    activity->acl_done = nullptr;
-
-    /* activity->fi 暂时不清理, 直到setFuncActivityAddVar时才清理 */
-    activity->body_next = nullptr;
-}
-
-/*
- * 函数名: af_ActivityTrackBack
- * 目标: 把 activity 上的内容转移到新的 af_ActivityTrackBack 上
- */
-static af_ActivityTrackBack *makeActivityTrackBack(af_Activity *activity) {
-    auto atb = calloc(1, af_ActivityTrackBack);
-#define EXCHANGE(name) (atb->name = activity->name)
-    EXCHANGE(file);
-    atb->file = strCopy(activity->file);
-    EXCHANGE(status);
-    EXCHANGE(line);
-    EXCHANGE(return_first);
-    EXCHANGE(run_in_func);
-    EXCHANGE(is_macro_call);
-    EXCHANGE(is_gc_call);
-    EXCHANGE(is_literal);
-    EXCHANGE(is_obj_func);
-    EXCHANGE(is_execution);
-    EXCHANGE(optimization);
-#undef EXCHANGE
-    return atb;
-}
-
-static af_ActivityTrackBack *freeActivityTrackBack(af_ActivityTrackBack *atb) {
-    af_ActivityTrackBack *next = atb->next;
-    free(atb->file);
-    free(atb);
-    return next;
-}
-
-static void freeAllActivityTrackBack(af_ActivityTrackBack *atb) {
-    while (atb != nullptr)
-        atb = freeActivityTrackBack(atb);
-}
-
-/*
- * 函数名: tailCallActivity
- * 目标: 记录ActivityTrackBack然后清除Activity
- */
-static void tailCallActivity(af_Object *func, af_Activity *activity) {
-    af_ActivityTrackBack *atb = makeActivityTrackBack(activity);
-    atb->next = activity->tb;
-    clearFuncActivity(activity);
-    activity->tb = atb;
-
-    pthread_mutex_lock(activity->gc_lock);
-    activity->func = func;
-    pthread_mutex_unlock(activity->gc_lock);
-}
-
-/*
- * 函数名: setActivityBtTop
- * 目标: 设置activity的bt_top, 并且设置行号
- * bt_start和bt_next会被设置为nullptr
- */
-void setActivityBtTop(af_Code *bt_top, af_Activity *activity) {
-    activity->bt_top = bt_top;
-    activity->bt_start = nullptr;
-    activity->bt_next = nullptr;
-    if (bt_top != nullptr) {
-        activity->line = bt_top->line;
-        if (bt_top->path != nullptr) {
-            free(activity->file);
-            activity->file = strCopy(bt_top->path);
-        }
-    } else
-        activity->line = 1;
-}
-
-/*
- * 函数名: setActivityBtStart
- * 目标: 设置activity的bt_start, 并且设置行号
- * bt_next会被设置为nullptr
- */
-void setActivityBtStart(af_Code *bt_start, af_Activity *activity) {
-    activity->bt_start = bt_start;
-    activity->bt_next = bt_start;
-    if (bt_start != nullptr) {
-        activity->line = bt_start->line;
-        if (bt_start->path != nullptr) {
-            free(activity->file);
-            activity->file = strCopy(bt_start->path);
-        }
-    } else
-        activity->line = 1;
-}
-
-/*
- * 函数名: setActivityBtNext
- * 目标: 设置activity的bt_next, 并且设置行号
- */
-void setActivityBtNext(af_Code *bt_next, af_Activity *activity) {
-    activity->bt_next = bt_next;
-    if (bt_next != nullptr) {
-        activity->line = bt_next->line;
-        if (bt_next->path != nullptr) {
-            free(activity->file);
-            activity->file = strCopy(bt_next->path);
-        }
-    } else
-        activity->line = 1;
-}
-
-/*
- * 函数名: makeLiteralDataList
- * 目标: 生成一个 af_LiteralDataList
- * 注意: char *data 要求传入一个已经被复制的data值
- * makeLiteralDataList是内部函数, 属于可控函数, 因此data在函数内部不再复制
- */
-static af_LiteralDataList *makeLiteralDataList(char *data) {
-    auto ld = calloc(1, af_LiteralDataList);
-    ld->literal_data = data;
-    return ld;
-}
-
-static af_LiteralDataList *freeLiteralData_Pri(af_LiteralDataList *ld) {
-    af_LiteralDataList *next = ld->next;
-    free(ld->literal_data);
-    free(ld);
-    return next;
-}
-
-void freeAllLiteralData(af_LiteralDataList *ld) {
-    while (ld != nullptr)
-        ld = freeLiteralData_Pri(ld);
-}
-
-void pushLiteralData(char *data, af_Environment *env) {
-    af_LiteralDataList *ld = makeLiteralDataList(data);
-    ld->next = env->activity->ld;
-    env->activity->ld = ld;
-}
-
-af_Message *makeMessage(const char *type, size_t size) {
-    auto msg = calloc(1, af_Message);
-    msg->type = strCopy(type);
-    if (size != 0)
-        msg->msg = calloc_size(1, size);
-    msg->size = size;
-    return msg;
-}
-
-af_Message *freeMessage(af_Message *msg) {
-    af_Message *next = msg->next;
-    free(msg->type);
-    free(msg->msg);
-    free(msg);
-    return next;
-}
-
-void freeAllMessage(af_Message *msg) {
-    while (msg != nullptr)
-        msg = freeMessage(msg);
-}
-
-bool freeMessageCount(size_t count, af_Message *msg) {
-    for (size_t i = count; i > 0; i--) {
-        if (msg == nullptr)  // 发生了错误
-            return false;
-        msg = freeMessage(msg);
-    }
-    return true;
-}
-
-void pushMessageUp(af_Message *msg, af_Environment *env) {
-    msg->next = env->activity->msg_up;
-    env->activity->msg_up = msg;
-    env->activity->msg_up_count++;
-}
-
-void pushMessageDown(af_Message *msg, af_Environment *env) {
-    msg->next = env->activity->msg_down;
-    env->activity->msg_down = msg;
-}
-
-void *popMessageUpData(const char *type, af_Environment *env) {
-    for (af_Message **pmsg = &env->activity->msg_up; *pmsg != nullptr; pmsg = &((*pmsg)->next)) {
-        if (EQ_STR((*pmsg)->type, type))
-            return (*pmsg)->msg;  // msg_up是只读的
-    }
-    return nullptr;
-}
-
-af_Message *popMessageUp(af_Environment *env) {
-    if (env->activity->msg_up_count == 0 || env->activity->msg_up == nullptr)
-        return nullptr;
-
-    af_Message *msg = env->activity->msg_up;
-    env->activity->msg_up = msg->next;
-    msg->next = nullptr;
-    env->activity->msg_up_count--;
-    return msg;
-}
-
-/*
- * 函数名: getMessageData
- * 目标: 获取`msg`的数据, 对外API
- */
-void *getMessageData(af_Message *msg) {
-    return msg->msg;
-}
-
-af_Message *popMessageDown(const char *type, af_Environment *env) {
-    for (af_Message **pmsg = &env->activity->msg_down; *pmsg != nullptr; pmsg = &((*pmsg)->next)) {
-        if (EQ_STR((*pmsg)->type, type)) {
-            af_Message *msg = *pmsg;
-            *pmsg = msg->next;
-            msg->next = nullptr;
-            return msg;
-        }
-    }
-    return nullptr;
-}
-
-af_Message *getFirstMessage(af_Environment *env) {
-    af_Message *msg = env->activity->msg_down;
-    env->activity->msg_down = msg->next;
-    msg->next = nullptr;
-    return msg;
-}
-
-void connectMessage(af_Message **base, af_Message *msg) {
-    while (*base != nullptr)
-        base = &((*base)->next);
-    *base = msg;
-}
-
-/**
- * 生成类型为NORMAL的Message
- * 注意: obj 必须提前添加 gc_addReference
- * @param obj
- * @param env
- * @return
- */
-af_Message *makeNORMALMessage(af_Object *obj, af_Environment *env){
-    af_Message *msg = makeMessage("NORMAL", sizeof(af_Object *));
-    *(af_Object **)msg->msg = obj;
-    return msg;
-}
-
-af_Message *makeERRORMessage(const char *type, const char *error, af_Environment *env) {
-    char *info = nullptr;
-    af_ErrorInfo *ei = nullptr;
-
-    for (af_Activity *activity = env->activity; activity != nullptr; activity = activity->prev) {
-        info = getActivityInfoToBacktracking(activity);
-        if (ei == nullptr)
-            ei = makeErrorInfo(type, error, info, env->activity->line, env->activity->file);
-        else
-            pushErrorBacktracking(activity->line, activity->file, info, ei);
-        free(info);
-
-        for (af_ActivityTrackBack *atb = activity->tb; atb != nullptr; atb = atb->next) {
-            info = getActivityTrackBackInfoToBacktracking(atb);
-            pushErrorBacktracking(atb->line, atb->file, info, ei);
-            free(info);
-        }
-    }
-
-    af_Message *msg = makeMessage("ERROR", sizeof(af_ErrorInfo *));
-    *(af_ErrorInfo **)msg->msg = ei;
-    return msg;
-}
-
-af_Message *makeERRORMessageFormat(const char *type, af_Environment *env, const char *format, ...) {
-    char buf[1024];
-    va_list ap;
-    va_start(ap, format);
-    vsnprintf(buf, 1024, format, ap);
-    va_end(ap);
-    return makeERRORMessage(type, buf, env);;
-}
-
-/**
- * 生成类型为IMPORT的Message
- * 注意: obj 必须提前添加 gc_addReference
- * @param mark
- * @param obj
- * @param env
- * @return
- */
-af_Message *makeIMPORTMessage(const char *mark, af_Object *obj, af_Environment *env){
-    af_Message *msg = makeMessage("IMPORT", sizeof(af_ImportInfo *));
-    *(af_ImportInfo **)msg->msg = makeImportInfo(mark, obj, env);
-    return msg;
-}
-
-static af_EnvVar *makeEnvVar(const char *name) {
-    auto var = calloc(1, af_EnvVar);
-    var->name = strCopy(name);
-    return var;
-}
-
-static af_EnvVar *freeEnvVar(af_EnvVar *var) {
-    af_EnvVar *next = var->next;
-    free(var->data);
-    free(var->name);
-    free(var);
-    return next;
-}
-
-static void freeAllEnvVar(af_EnvVar *var) {
-    while (var != nullptr)
-        var = freeEnvVar(var);
-}
-
-static af_EnvVarSpace *makeEnvVarSpace() {
-    auto evs = calloc(1, af_EnvVarSpace);
-    pthread_rwlock_init(&evs->lock, nullptr);
-    return evs;
-}
-
-static void freeEnvVarSpace(af_EnvVarSpace *evs) {
-    for (int i = 0; i < ENV_VAR_HASH_SIZE; i++)
-        freeAllEnvVar(evs->var[i]);
-    pthread_rwlock_destroy(&evs->lock);
-    free(evs);
-}
-
-af_EnvVar *setEnvVarData_(const char *name, const char *data, af_Environment *env) {
-    time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
-    pthread_rwlock_wrlock(&env->esv->lock);
-
-    af_EnvVar **pvar = &env->esv->var[index];
-    env->esv->count++;
-    for(NULL; *pvar != nullptr; pvar = &((*pvar)->next)) {
-        if (EQ_STR((*pvar)->name, name)) {
-            free((*pvar)->data);
-            (*pvar)->data = strCopy(data);
-            pthread_rwlock_unlock(&env->esv->lock);
-            return *pvar;
-        }
-    }
-
-    *pvar = makeEnvVar(name);
-    (*pvar)->data = strCopy(data);
-    pthread_rwlock_unlock(&env->esv->lock);
-    return *pvar;
-}
-
-af_EnvVar *setEnvVarNumber_(const char *name, int32_t data, af_Environment *env) {
-    time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
-    pthread_rwlock_wrlock(&env->esv->lock);
-
-    af_EnvVar **pvar = &env->esv->var[index];
-    env->esv->count++;
-    for(NULL; *pvar != nullptr; pvar = &((*pvar)->next)) {
-        if (EQ_STR((*pvar)->name, name)) {
-            free((*pvar)->data);
-            (*pvar)->num = data;
-            pthread_rwlock_unlock(&env->esv->lock);
-            return *pvar;
-        }
-    }
-
-    *pvar = makeEnvVar(name);
-    (*pvar)->num = data;
-    pthread_rwlock_unlock(&env->esv->lock);
-    return *pvar;
-}
-
-void setEnvVarData(const char *name, const char *data, af_Environment *env) {
-    setEnvVarData_(name, data, env);
-}
-
-void setEnvVarNumber(const char *name, int32_t data, af_Environment *env) {
-    setEnvVarNumber_(name, data, env);
-}
-
-char *findEnvVarData(const char *name, af_Environment *env) {
-    time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
-    pthread_rwlock_rdlock(&env->esv->lock);
-
-    af_EnvVar **pvar = &env->esv->var[index];
-    for(NULL; *pvar != nullptr; pvar = &((*pvar)->next)) {
-        if (EQ_STR((*pvar)->name, name)) {
-            char *data = (*pvar)->data;
-            pthread_rwlock_unlock(&env->esv->lock);
-            return data;
-        }
-    }
-
-    pthread_rwlock_unlock(&env->esv->lock);
-    return nullptr;
-}
-
-int32_t *findEnvVarNumber(const char *name, af_Environment *env) {
-    time33_t index = time33(name) % ENV_VAR_HASH_SIZE;
-    pthread_rwlock_rdlock(&env->esv->lock);
-
-    af_EnvVar **pvar = &env->esv->var[index];
-    for(NULL; *pvar != nullptr; pvar = &((*pvar)->next)) {
-        if (EQ_STR((*pvar)->name, name)) {
-            int32_t *data = &(*pvar)->num;  // 返回指针, nullptr表示没找到
-            pthread_rwlock_unlock(&env->esv->lock);
-            return data;
-        }
-    }
-
-    pthread_rwlock_unlock(&env->esv->lock);
-    return nullptr;
-}
-
-static void mp_NORMAL(af_Message *msg, bool is_top, af_Environment *env) {
-    if (msg->msg == nullptr || *(af_Object **)msg->msg == nullptr) {
-        writeErrorLog(aFunCoreLogger, "NORMAL msg: %p error", msg->msg);
-        return;
-    }
-    if (is_top)
-        writeDebugLog(aFunCoreLogger, "NORMAL Point: %p", *(af_Object **)msg->msg);
-    gc_delObjectReference(*(af_Object **)msg->msg, env);
-    *(af_Object **)msg->msg = nullptr;
-}
-
-static void mp_NORMALThread(af_Message *msg, bool is_top, af_Environment *env) {
-    if (msg->msg == nullptr || *(af_Object **)msg->msg == nullptr) {
-        writeErrorLog(aFunCoreLogger, "Thread-NORMAL msg: %p error", msg->msg);
-        return;
-    }
-
-    if (is_top)
-        writeDebugLog(aFunCoreLogger, "Thread-NORMAL Point: %p", *(af_Object **)msg->msg);
-
-    pthread_mutex_lock(&env->thread_lock);
-    env->result = *(af_Object **)msg->msg;
-    gc_delObjectReference(env->result, env);
-    *(af_Object **)msg->msg = nullptr;
-    pthread_mutex_unlock(&env->thread_lock);
-}
-
-static void mp_ERROR(af_Message *msg, bool is_top, af_Environment *env) {
-    if (msg->msg == nullptr || *(af_ErrorInfo **)msg->msg == nullptr) {
-        writeErrorLog(aFunCoreLogger, "ERROR msg: %p error", msg->msg);
-        return;
-    }
-    if (is_top) {
-        if (getErrorStd(env) == 0)
-            fprintfErrorInfoStdout(*(af_ErrorInfo **) msg->msg);
-        else
-            fprintfErrorInfoStderr(*(af_ErrorInfo **) msg->msg);
-    }
-    freeErrorInfo(*(af_ErrorInfo **) msg->msg, env);
-}
-
-static void mp_IMPORT(af_Message *msg, bool is_top, af_Environment *env) {
-    if (msg->msg == nullptr || *(af_ImportInfo **)msg->msg == nullptr) {
-        writeErrorLog(aFunCoreLogger, "IMPORT msg: %p error", msg->msg);
-        return;
-    }
-    af_ImportInfo *ii = *(af_ImportInfo **)msg->msg;
-    if (ii->obj == nullptr) {
-        writeErrorLog(aFunCoreLogger, "IMPORT msg: %p do not get obj", msg->msg);
-        return;
-    }
-
-    if (ii->mark != nullptr) {
-        makeVarToProtectVarSpace(ii->mark, 3, 3, 3, ii->obj, env);
-        writeDebugLog(aFunCoreLogger, "IMPORT point: [%s] %p", ii->mark, ii->obj);
-    } else
-        writeDebugLog(aFunCoreLogger, "IMPORT point: <no-name> %p", ii->obj);
-    freeImportInfo(ii, env);
-}
-
-af_Environment *makeEnvironment(enum GcRunTime grt) {
-    auto env = calloc(1, af_Environment);
-
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
-    pthread_mutex_init(&env->in_run, &attr);  // 检测锁
-    pthread_mutexattr_destroy(&attr);
-
-    pthread_mutex_init(&env->thread_lock, nullptr);
-    pthread_mutex_init(&env->status_lock, nullptr);
-
-    env->is_derive = false;
-    env->base = env;
-
-    env->gc_factory = makegGcFactory();
-    env->esv = makeEnvVarSpace();
-
-    /* 设置默认prefix */
-    char prefix[PREFIX_SIZE + 1] = "";
-    prefix[E_QUOTE] = '\'';
-    prefix[B_EXEC] = '\'';
-    prefix[B_EXEC_FIRST] = '$';
-    env->prefix = setEnvVarData_(ev_sys_prefix, prefix, env);
-    env->gc_runtime = setEnvVarNumber_(ev_grt, grt, env);
-    env->gc_max = setEnvVarNumber_(ev_gcmax, DEFAULT_GC_COUNT_MAX, env);
-    env->gc_count = setEnvVarNumber_(ev_gccount, 0, env);
-    env->exit_code_ = setEnvVarNumber_(ev_exit_code, 0, env);
-    env->argc = setEnvVarNumber_(ev_argc, 0, env);
-    env->error_std = setEnvVarNumber_(ev_error_std, 0, env);
-
-    /* 创建保护空间 */
-    env->protect = makeVarSpace(nullptr, 3, 3, 3, env);
-
-    /* 生成global对象 */
-    env->global = makeGlobalObject(env);
-
-    /* 设置NORMAL顶级处理器 */
-    DLC_SYMBOL(TopMsgProcessFunc) func1 = MAKE_SYMBOL(mp_NORMAL, TopMsgProcessFunc);
-    addTopMsgProcess("NORMAL", func1, env);
-    FREE_SYMBOL(func1);
-
-    DLC_SYMBOL(TopMsgProcessFunc) func2 = MAKE_SYMBOL(mp_ERROR, TopMsgProcessFunc);
-    addTopMsgProcess("ERROR", func2, env);
-    FREE_SYMBOL(func2);
-
-    DLC_SYMBOL(TopMsgProcessFunc) func3 = MAKE_SYMBOL(mp_IMPORT, TopMsgProcessFunc);
-    addTopMsgProcess("IMPORT", func3, env);
-    FREE_SYMBOL(func3);
-
-    env->status = core_init;
-    env->activity = makeTopActivity(nullptr, nullptr, env->protect, env->global, env);
-
-    makeVarToProtectVarSpace("global", 3, 3, 3, env->global, env);
-
-    gc_delVarSpaceReference(env->protect, env);
-    gc_delObjectReference(env->global, env);
-    return env;
-}
-
-af_Environment *deriveEnvironment(bool derive_tmp, bool derive_guardian, bool derive_lr, bool enable,
-                                  af_Environment *base) {
-    auto env = calloc(1, af_Environment);
-
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
-    pthread_mutex_init(&env->in_run, &attr);  // 检测锁
-    pthread_mutexattr_destroy(&attr);
-
-    pthread_mutex_init(&env->thread_lock, nullptr);
-    pthread_mutex_init(&env->status_lock, nullptr);
-
-    env->is_derive = true;
-    env->base = base->base;
-    pushEnvironmentList(env, base);
-
-#define D(v) env->v = (env->base)->v
-    D(gc_factory);
-    D(esv);
-    D(prefix);
-    D(gc_runtime);
-    D(gc_max);
-    D(gc_count);
-    D(exit_code_);
-    D(argc);
-    D(error_std);
-    D(protect);
-    D(global);
-#undef D
-
-    if (derive_tmp) {
-        for (af_TopMsgProcess *tmp = base->process; tmp != nullptr; tmp = tmp->next)
-            addTopMsgProcess(tmp->type, tmp->func, env);
-    }
-
-    DLC_SYMBOL(TopMsgProcessFunc) func1 = MAKE_SYMBOL(mp_NORMALThread, TopMsgProcessFunc);
-    af_TopMsgProcess *tmp = findTopMsgProcessFunc("NORMAL", env);
-    if (tmp == nullptr) {
-        addTopMsgProcess("NORMAL", func1, env);
-        FREE_SYMBOL(func1);
-    } else {
-        FREE_SYMBOL(tmp->func);
-        tmp->func = func1;
-    }
-
-    if (derive_guardian) {
-        for (af_Guardian *gu = base->guardian; gu != nullptr; gu = gu->next) {
-            if (gu->derive)
-                addGuardian(gu->type, gu->always, true, gu->size, gu->func, gu->destruct, nullptr, env);
-        }
-    }
-
-    if (derive_lr) {
-        for (af_LiteralRegex *lr = base->lr; lr != nullptr; lr = lr->next)
-            pushLiteralRegex(lr->pattern, lr->func, lr->in_protect, env);
-    }
-
-    if (enable)
-        env->status = core_normal;
-    else
-        env->status = core_init;
-
-    env->activity = makeTopActivity(nullptr, nullptr, env->protect, env->global, env);
-    return env;
-}
-
-void enableEnvironment(af_Environment *env) {
-    env->status = core_normal;
-}
-
-bool freeEnvironment(af_Environment *env) {
-    bool res = true;
-    if (!env->is_derive && getEnviromentSonCount(env) != 0)
-        return false;
-
-    if (!env->is_derive && env->status != core_creat)
-        res = iterDestruct(10, env);
-
-    freeAllActivity(env->activity, env);
-    freeAllTopMsgProcess(env->process);
-    freeAllGuardian(env->guardian, env);
-    freeAllLiteralRegex(env->lr);
-
-    if (!env->is_derive) {
-        freeEnvVarSpace(env->esv);
-
-        gc_freeAllValueData(env);  // 先释放ObjectData的void *data
-        printGCByCore(env);
-        gc_freeAllValue(env);  // 再完全释放Object
-        freeGcFactory(env->gc_factory);
-    } else
-        freeEnvironmentListByEnv(env, env->base);
-
-    pthread_mutex_destroy(&env->in_run);
-    pthread_mutex_destroy(&env->thread_lock);
-    if (!res)
-        writeErrorLog(aFunCoreLogger, "Run iterDestruct error.");
-    free(env);
-    return true;
-}
-
-static af_TopMsgProcess *makeTopMsgProcess(const char *type, DLC_SYMBOL(TopMsgProcessFunc) func) {
-    auto mp = calloc(1, af_TopMsgProcess);
-    mp->type = strCopy(type);
-    mp->func = COPY_SYMBOL(func, TopMsgProcessFunc);
-    return mp;
-}
-
-static af_TopMsgProcess *freeTopMsgProcess(af_TopMsgProcess *mp) {
-    af_TopMsgProcess *next = mp->next;
-    free(mp->type);
-    FREE_SYMBOL(mp->func);
-    free(mp);
-    return next;
-}
-
-static void freeAllTopMsgProcess(af_TopMsgProcess *mp) {
-    while (mp != nullptr)
-        mp = freeTopMsgProcess(mp);
-}
-
-static af_TopMsgProcess *findTopMsgProcessFunc(const char *type, af_Environment *env) {
-    auto mp = env->process;
-    for(NULL; mp != nullptr; mp = mp->next) {
-        if (EQ_STR(type, mp->type))
-            return mp;
-    }
-    return nullptr;
-}
-
-bool addTopMsgProcess(const char *type, DLC_SYMBOL(TopMsgProcessFunc) func, af_Environment *env) {
-    auto mp = findTopMsgProcessFunc(type, env);
-    if (mp != nullptr)
-        return false;
-
-    mp = makeTopMsgProcess(type, func);
-    mp->next = env->process;
-    env->process = mp;
-    return true;
-}
-
-static af_Guardian *makeGuardian(const char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
-                                 DLC_SYMBOL(GuardianDestruct) destruct){
-    auto gd = calloc(1, af_Guardian);
-    gd->type = strCopy(type);
-    gd->always = always;
-    gd->derive = derive;
-
-    if (size != 0) {
-        gd->data = calloc_size(1, size);
-        gd->size = size;
-    }
-
-    gd->func = COPY_SYMBOL(func, GuardianFunc);
-
-    if (destruct != nullptr)
-        gd->destruct = COPY_SYMBOL(destruct, GuardianDestruct);
-    return gd;
-}
-
-static af_Guardian *freeGuardian(af_Guardian *gd, af_Environment *env) {
-    af_Guardian *next = gd->next;
-    if (gd->data != nullptr && gd->destruct != nullptr)
-        GET_SYMBOL(gd->destruct)(gd->type, gd->data, env);
-    free(gd->data);
-    free(gd->type);
-    FREE_SYMBOL(gd->func);
-    FREE_SYMBOL(gd->destruct);
-    free(gd);
-    return next;
-}
-
-static void freeAllGuardian(af_Guardian *gd, af_Environment *env) {
-    while (gd != nullptr)
-        gd = freeGuardian(gd, env);
-}
-
-static af_Guardian *findGuardian(const char *type, af_Environment *env) {
-    af_Guardian *gd = env->guardian;
-    for(NULL; gd != nullptr; gd = gd->next) {
-        if (EQ_STR(type, gd->type))
-            return gd;
-    }
-    return nullptr;
-}
-
-bool addGuardian(const char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
-                 DLC_SYMBOL(GuardianDestruct) destruct, void **pdata, af_Environment *env){
-    af_Guardian *gd = findGuardian(type, env);
-    if (gd != nullptr)
-        return false;
-
-    gd = makeGuardian(type, always, derive, size, func, destruct);
-    gd->next = env->guardian;
-    env->guardian = gd;
-    if (pdata != nullptr)
-        *pdata = gd->data;
-    return true;
-}
-
-bool popGuardian(const char *type, af_Environment *env) {
-    af_Guardian **gd = &env->guardian;
-    for(NULL; *gd != nullptr; gd = &((*gd)->next)) {
-        if (EQ_STR(type, (*gd)->type)) {
-            *gd = freeGuardian(*gd, env);
-            return true;
-        }
-    }
-
-    return false;
-}
-
-static void newFuncActivity(af_Code *bt, const af_Code *next, bool return_first, af_Environment *env){
-    if (next == nullptr && env->activity->body_next == nullptr &&
-        env->activity->type == act_func && env->activity->macro_varlist == nullptr) {
-        writeDebugLog(aFunCoreLogger, "Tail call optimization");
-        tailCallActivity(getActivityFunc(env), env->activity);
-        setActivityBtTop(bt, env->activity);
-        env->activity->optimization = true;
-        if (!env->activity->return_first)  // 若原本就有设置 return_first 则没有在设置的必要了, 因为该执行不会被返回
-            env->activity->return_first = return_first;
-    } else {
-        af_Activity *activity = makeFuncActivity(bt, nullptr, return_first, env->activity->msg_up,
-                                                 env->activity->run_varlist, env->activity->belong,
-                                                 getActivityFunc(env), env);
-        pushActivity(activity, env);
-    }
-}
-
-/*
- * 函数名: isInfixFunc
- * 目标: 检查是否中缀调用函数
- */
-static bool isInfixFunc(af_Code *code, af_Environment *env) {
-    if (code == nullptr || code->type != code_element || code->prefix == getPrefix(E_QUOTE, env))  // 检查是否element, 且无引用前缀
-        return false;
-
-    if (checkLiteralCode(code->element.data, nullptr, nullptr, env))  // 检查是否字面量
-        return false;
-
-    writeDebugLog(aFunCoreLogger, "isInfixFunc: %s\n", code->element.data);
-    af_Var *var = findVarFromVarList(code->element.data, env->activity->belong, env->activity->run_varlist);
-    if (var == nullptr)
-        return false;
-
-    af_Object *obj = findVarNode(var, nullptr, env);
-    auto func = (obj_isInfixFunc *)findAPI("obj_isInfixFunc", getObjectAPI(obj));
-    if (func == nullptr) {
-        gc_delObjectReference(obj, env);
-        return false;
-    }
-
-    bool res = func(getObjectID(obj), obj);
-    gc_delObjectReference(obj, env);
-    return res;
-}
-
-bool pushExecutionActivity(af_Code *bt, bool return_first, af_Environment *env) {
-    af_Code *next;
-    next = getCodeNext(bt);
-    writeDebugLog(aFunCoreLogger, "Run execution");
-
-    if (bt->type != code_block || bt->block.is_empty) {
-        pushMessageDown(makeERRORMessage(SYNTAX_ERROR, NOT_CODE_INFO, env), env);
-        return false;
-    }
-
-    setActivityBtNext(next, env->activity);
-
-    newFuncActivity(bt, next, return_first, env);
-    setActivityBtStart(bt->next, env->activity);
-
-    env->activity->status = act_func_normal;
-    env->activity->is_execution = true;
-    return true;
-}
-
-bool pushFuncActivity(af_Code *bt, af_Environment *env) {
-    af_Code *next;
-    af_Code *func;
-    af_Object *parentheses_call = env->activity->parentheses_call;
-
-    pthread_mutex_lock(env->activity->gc_lock);
-    env->activity->parentheses_call = nullptr;
-    pthread_mutex_unlock(env->activity->gc_lock);
-
-    writeDebugLog(aFunCoreLogger, "Run func");
-    next = getCodeNext(bt);
-    switch (bt->block.type) {
-        case curly:
-            if (bt->block.is_empty) {
-                pushMessageDown(makeERRORMessage(CALL_ERROR, CURLY_FUNC_BODY_INFO, env), env);
-                return false;
-            }
-            func = bt->next;
-            break;
-        case brackets:
-            func = nullptr;
-            for (af_Code *code = bt->next; code != nullptr; code = getCodeNext(code)) {
-                if (isInfixFunc(code, env)) {
-                    func = code;
-                    break;
-                }
-            }
-            if (func == nullptr) {
-                pushMessageDown(makeERRORMessage(CALL_ERROR, BRACKETS_FUNC_BODY_INFO, env), env);
-                return false;
-            }
-            break;
-        case parentheses:
-            func = nullptr;  // 小括号则不在需要匹配
-            break;
-        default:
-            break;
-    }
-
-    setActivityBtNext(next, env->activity);  // 设置当前Activity的bt_next
-
-    newFuncActivity(bt, next, false, env);  // 添加新的Activity或尾调用优化
-    setActivityBtStart(func, env->activity);
-
-    env->activity->call_type = env->activity->bt_top->block.type;  // newActivity时会设置bt_top
-    env->activity->status = act_func_get;
-    if (env->activity->call_type == parentheses) { // 对于类前缀调用, 已经获得func的实际值了
-        if (parentheses_call == nullptr) {
-            pushMessageDown(makeERRORMessage(CALL_ERROR, PARENTHESES_FUNC_BODY_INFO, env), env);
-            return false;
-        }
-        return setFuncActivityToArg(parentheses_call, env);
-    }
-    return true;
-}
-
-bool pushLiteralActivity(af_Code *bt, const char *data, af_Object *func, af_Environment *env) {
-    setActivityBtNext(bt->next, env->activity);
-
-    writeDebugLog(aFunCoreLogger, "Run literal");
-    newFuncActivity(bt, bt->next, false, env);
-    env->activity->is_literal = true;
-    pushLiteralData(strCopy(data), env);  // FuncBody的释放导致code和literal_data释放, 所以要复制
-    return setFuncActivityToArg(func, env);
-}
-
-bool pushVariableActivity(af_Code *bt, af_Object *func, af_Environment *env) {
-    setActivityBtNext(bt->next, env->activity);
-
-    writeDebugLog(aFunCoreLogger, "Run variable");
-    newFuncActivity(bt, bt->next, false, env);
-    env->activity->is_obj_func = true;
-    return setFuncActivityToArg(func, env);
-}
-
-bool pushMacroFuncActivity(af_Object *func, af_Environment *env) {
-    /* Macro是隐式调用, bt不移动 */
-    /* 沿用activity */
-    af_VarList *macro_varlist = env->activity->macro_varlist;
-    ActivityCount count = env->activity->count_macro_varlist;
-    env->activity->count_macro_varlist = 0;
-
-    pthread_mutex_lock(env->activity->gc_lock);
-    af_VarList *tmp = env->activity->run_varlist;
-    env->activity->run_varlist = nullptr;
-    pthread_mutex_unlock(env->activity->gc_lock);
-
-    writeDebugLog(aFunCoreLogger, "Run macro");
-    if (!freeVarSpaceListCount(env->activity->count_run_varlist, tmp)) { // 释放外部变量空间
-        env->activity->count_run_varlist = 0;
-        pushMessageDown(makeERRORMessage(RUN_ERROR, FREE_VARSPACE_INFO, env), env);
-        return false;
-    }
-
-    env->activity->count_run_varlist = 0;
-    tailCallActivity(func, env->activity);  /* 隐式调用不设置 bt_top */
-
-    /* tailCallActivity 会清除 out_varlist 的设定 */
-    pthread_mutex_lock(env->activity->gc_lock);
-    env->activity->out_varlist = macro_varlist;
-    env->activity->count_out_varlist = count;
-    env->activity->is_macro_call = true;
-    pthread_mutex_unlock(env->activity->gc_lock);
-    return setFuncActivityToArg(func, env);
-}
-
-void pushGuardianActivity(af_GuardianList *gl, af_GuardianList **pgl, af_Environment *env) {
-    for (af_Activity *tmp = env->activity; tmp != nullptr; tmp = tmp->prev) {
-        if (tmp->type == act_guardian) {
-            *(tmp->pgl) = gl;
-            tmp->pgl = pgl;
-            if (tmp->gl_next == nullptr)  // 原dl_next已经运行到末端
-                tmp->gl_next = gl;
-            return;
-        }
-    }
-
-    /* gc Activity 可能创建为顶层 activity, 故信息不能继承上一级(可能没有上一级) */
-    af_Activity *activity = makeGuardianActivity(gl, pgl, env);
-    pushActivity(activity, env);
-}
-
-bool pushImportActivity(af_Code *bt, af_Object **obj, const char *mark, af_Environment *env) {
-    af_Object *tmp = nullptr;
-    if (obj != nullptr)
-        tmp = *obj;
-
-    if (tmp == nullptr)
-        tmp = makeGlobalObject(env);
-
-    af_Activity *activity = makeTopImportActivity(bt, bt, env->protect, tmp, mark, env);
-    pushActivity(activity, env);
-
-    if (obj != nullptr)
-        *obj = tmp;
-    else
-        gc_delObjectReference(tmp, env);
-
-    return true;
-}
-
-bool pushGuadianFuncActivity(af_GuardianList *gl, af_Environment *env) {
-    env->activity->gl_next = gl->next;
-
-    af_Object *belong = gl->obj != nullptr ? gl->obj : env->global;
-    /* 隐式调用不设置 bt_top */
-    af_Activity *activity = makeFuncActivity(nullptr, nullptr, false, env->activity->msg_up,
-                                             env->activity->run_varlist, belong, nullptr, env);
-    activity->is_guard_call = true;
-    pushActivity(activity, env);
-    return setFuncActivityToArg(gl->func, env);
-}
-
-void setArgCodeListToActivity(af_ArgCodeList *acl, af_Environment *env) {
-    if (acl != nullptr) {
-        setActivityBtStart(acl->code, env->activity);
-        env->activity->run_in_func = acl->run_in_func;
-    } else {
-        setActivityBtStart(nullptr, env->activity);
-        env->activity->run_in_func = false;
-    }
-}
-
-bool setFuncActivityToArg(af_Object *func, af_Environment *env) {
-    af_ObjectAPI *api = getObjectAPI(func);
-    auto get_acl = (obj_funcGetArgCodeList *)findAPI("obj_funcGetArgCodeList", api);
-    auto get_var_list = (obj_funcGetVarList *)findAPI("obj_funcGetVarList", api);
-    af_VarList *func_varlist = nullptr;
-    af_Object *belong = getBelongObject(func);
-
-    if (get_var_list == nullptr) {
-        pushMessageDown(makeERRORMessage(TYPE_ERROR, API_NOT_FOUND_INFO(obj_funcGetVarList), env), env);
-        return false;
-    }
-
-    pthread_mutex_lock(env->activity->gc_lock);
-    env->activity->func = func;
-    env->activity->belong = belong;
-    env->activity->status = act_func_arg;
-    pthread_mutex_unlock(env->activity->gc_lock);
-
-    /* 遇到错误时 get_acl 和 get_var_list 要自行设定msg */
-    if (get_acl != nullptr) {
-        if (!get_acl(getObjectID(func), func, &env->activity->acl_start, env->activity->bt_top, &env->activity->mark, env))  // 设置acl
-            return false;
-    } else
-        env->activity->acl_start = nullptr;
-
-    if (!get_var_list(getObjectID(func), func, &env->activity->func_varlist, env->activity->mark, env))  // 设置 func_var_list
-        return false;
-
-    env->activity->acl_done = env->activity->acl_start;
-    setArgCodeListToActivity(env->activity->acl_start, env);
-    return true;
-}
-
-bool setFuncActivityAddVar(af_Environment *env){
-    af_ObjectAPI *api = getObjectAPI(env->activity->func);
-    auto get_info = (obj_funcGetInfo *)findAPI("obj_funcGetInfo", api);
-    auto get_arg_list = (obj_funcGetArgList *)findAPI("obj_funcGetArgList", api);
-    af_FuncInfo *fi = nullptr;
-
-    if (get_info == nullptr) {
-        pushMessageDown(makeERRORMessage(TYPE_ERROR, API_NOT_FOUND_INFO(obj_funcGetInfo), env), env);
-        return false;
-    }
-
-    /* env->activity->fi可能还存储着旧的FuncInfo(尾调用优化), 因此不能直接保存到 env->activity->fi 中 */
-    if (!get_info(getObjectID(env->activity->func), env->activity->func, &fi, env->activity->bt_top, env->activity->mark, env))
-        return false;
-    if (fi == nullptr) {
-        pushMessageDown(makeERRORMessage(API_RUN_ERROR, API_DONOT_GIVE(FuncInfo), env), env);
-        return false;
-    }
-
-    if (fi->scope == super_pure_scope && env->activity->fi->embedded == super_embedded) {
-        /* 超纯函数和超内嵌函数不得搭配使用 */
-        pushMessageDown(makeERRORMessage(RUN_ERROR, PURE_EMBEDDED_INFO, env), env);
-        return false;
-    }
-
-    pthread_mutex_lock(env->activity->gc_lock);
-    if (fi->is_macro) {  // 是宏函数则保存变量空间
-        env->activity->macro_varlist = env->activity->out_varlist;
-        env->activity->count_macro_varlist = env->activity->count_out_varlist;
-        env->activity->count_out_varlist = 0;
-    }
-
-    if (fi->scope != inline_scope) {
-        env->activity->count_run_varlist = env->activity->count_out_varlist;
-        env->activity->count_out_varlist = 0;
-        env->activity->run_varlist = env->activity->out_varlist;
-    } else if  (fi->scope == normal_scope) { // 使用函数变量空间
-        env->activity->count_run_varlist = 0;
-        env->activity->run_varlist = env->activity->func_varlist;
-    } else if (fi->scope == pure_scope) {  // 纯函数只有 protect 变量空间
-        env->activity->count_run_varlist = 1;
-        env->activity->run_varlist = pushProtectVarList(nullptr, env);
-    } else if (fi->scope == super_pure_scope) {  // 超纯函数没有变量空间, 因此不得为超内嵌函数(否则var_list就为nullptr了)
-        env->activity->count_run_varlist = 0;
-        env->activity->run_varlist = nullptr;
-    }
-
-    env->activity->func_varlist = nullptr;
-    freeVarSpaceListCount(env->activity->count_out_varlist, env->activity->out_varlist);  // freeVarSpaceListCount 前释放, 避免死锁
-    env->activity->count_out_varlist = 0;
-    env->activity->out_varlist = nullptr;
-
-    if (fi->embedded != super_embedded) {  // 不是超内嵌函数则引入一层新的变量空间
-        /* 新层的变量空间应该属于belong而不是func */
-        env->activity->run_varlist = pushNewVarList(env->activity->belong, env->activity->run_varlist, env);;
-        env->activity->count_run_varlist++;
-        gc_delVarListReference(env->activity->run_varlist, env);
-    }
-    pthread_mutex_unlock(env->activity->gc_lock);
-
-    if (fi->var_this && env->activity->belong != nullptr) {
-        if (!makeVarToVarSpaceList("this", 3, 3, 3, env->activity->belong,
-                                   env->activity->run_varlist, env->activity->belong, env)) {
-            pushMessageDown(makeERRORMessage(RUN_ERROR, IMPLICIT_SET_INFO(this), env), env);
-            return false;
-        }
-    }
-
-    if (fi->var_func && env->activity->func != nullptr) {
-        if (!makeVarToVarSpaceList("func", 3, 3, 3, env->activity->func,
-                                   env->activity->run_varlist, env->activity->belong, env)) {
-            pushMessageDown(makeERRORMessage(RUN_ERROR, IMPLICIT_SET_INFO(func), env), env);
-            return false;
-        }
-    }
-
-    /* 计算参数 */
-    if (get_arg_list != nullptr) {
-        af_ArgList *al;
-        if (!get_arg_list(getObjectID(env->activity->func), env->activity->func, &al, env->activity->acl_start,
-                          env->activity->mark, env))
-            return false;
-        runArgList(al, env->activity->run_varlist, env);
-        freeAllArgList(al, env);
-    }
-
-    if (fi->embedded == protect_embedded)
-        setVarSpaceProtect(env->activity->belong, env->activity->run_varlist->vs, true);
-
-    /* ArgCodeList 在此处被清理 */
-    freeAllArgCodeList(env->activity->acl_start, env);
-    env->activity->acl_start = nullptr;
-    env->activity->acl_done = nullptr;
-
-    /* 此处检查fi是否为nullptr, 不为(通常为尾调用优化)则释放fi */
-    /* 旧的FuncBody延迟到此处才释放(freeFuncInfo释放FuncBody), 是因为获取函数参数的相关运算中可能会使用旧FuncBody中的代码 */
-    /* 因为调用函数的代码是在旧FuncBody中的, 因此参数计算的相关代码也可能在旧FuncBody中 */
-    /* 也就是说ArgCodeList, bt_top, bt_start中的代码可能是来自旧FuncBody的 */
-    /* 所以他们要延迟到现在才被释放 */
-    /* 而get_arg_list是最后一次使用旧FuncBody中的代码(bt_top), 因此此处可以释放 */
-    if (env->activity->fi != nullptr)
-        freeFuncInfo(env->activity->fi);  // 延迟到这里再释放, 主要是FuncBody中的bt可能会被使用
-    env->activity->fi = fi;
-    env->activity->body_next = fi->body;
-
-    /* bt_top等的相关设定会在 setFuncActivityToNormal 中被进行 */
-    if (setFuncActivityToNormal(env) == 0)
-        return false;  // 运行结束, 且已写入msg
-    return true;
-}
-
-static void initCallFuncInfo(af_CallFuncInfo *cfi, af_Environment *env) {
-    cfi->mark = env->activity->mark;
-    cfi->body_next = env->activity->body_next;
-
-    cfi->belong = env->activity->belong;
-    cfi->func = env->activity->func;
-    cfi->var_list = env->activity->run_varlist;
-
-    cfi->call_type = env->activity->call_type;
-    cfi->is_gc_call = env->activity->is_gc_call;
-    cfi->is_literal = env->activity->is_literal;
-    cfi->is_obj_func = env->activity->is_obj_func;
-    cfi->is_macro_call = env->activity->is_macro_call;
-}
-
-/*
- * 函数名: setFuncActivityToNormal
- * 目标: 获取下一步需要运行的结果
- * 返回  (0) 表示无下一步
- * 返回 (-1) 表示运行C函数, 并且设置了 process_msg_first
- * 返回  (1) 表示下一步运行Code
- * 返回  (2) 表示遇到未被替换的动态代码块
- */
-int setFuncActivityToNormal(af_Environment *env){  // 获取函数的函数体
-    int re;
-    af_FuncBody *body = env->activity->body_next;
-    env->activity->status = act_func_normal;
-    setActivityBtTop(nullptr, env->activity);  // NORMAL期, bt_top将不被设定
-    setActivityBtNext(nullptr, env->activity);
-
-    if (body == nullptr)  // 已经没有下一步了 (原msg不释放)
-        return 0;
-
-    af_Activity *activity = env->activity;  // 防止在函数调用期间env->activity被修改
-    env->activity->body_next = body->next;
-    switch (body->type) {
-        case func_body_c: {
-            af_CallFuncInfo cfi;
-            initCallFuncInfo(&cfi, env);
-
-            af_FuncBody *new_fb = GET_SYMBOL(body->c_func)(&cfi, env);
-            activity->process_msg_first++;  // 处理C函数通过msg_down返回的结果
-            if (cfi.body_next != env->activity->body_next) {
-                env->activity->body_next = cfi.body_next;
-                freeAllFuncBody(new_fb);  // 不再允许设定 FuncBody
-            } else {
-                pushDynamicFuncBody(new_fb, body);
-                activity->body_next = body->next;  // 添加新元素后要重新设定body_next的位置
-            }
-            re = -1;
-            break;
-        }
-        case func_body_import:
-            if (!pushImportActivity(body->code, nullptr, nullptr, env)) {
-                pushMessageDown(makeERRORMessage(IMPORT_ERROR, IMPORT_OBJ_ERROR, env), env);
-                activity->process_msg_first++;
-                re = 2;
-                break;
-            }
-            re = 1;
-            break;
-        case func_body_code:
-            setActivityBtStart(body->code, env->activity);
-            re = 1;
-            break;
-        default:
-        case func_body_dynamic:
-            pushMessageDown(makeERRORMessage(RUN_ERROR, FUNCBODY_ERROR_INFO, env), env);
-            activity->process_msg_first++;
-            re = 2;
-            break;
-    }
-
-    /* 在最后一个aFunBody完毕后, mark被释放(因为此后不会再有函数需要使用Mark) */
-    if (activity->body_next == nullptr)  // 最后一个aFunBody
-        freeMark(activity);
-    return re;
-}
-
-
-/*
- * 函数名: runTopMessageProcess
- * 目标: 运行顶层信息处理器
- */
-void runTopMessageProcess(bool is_top, af_Environment *env) {
-    af_Message **pmsg = &env->activity->msg_down;
-    while (*pmsg != nullptr) {
-        af_TopMsgProcess *mp = findTopMsgProcessFunc((*pmsg)->type, env);
-        if (mp != nullptr) {
-            GET_SYMBOL(mp->func)(*pmsg, is_top, env);
-            *pmsg = freeMessage(*pmsg);
-        } else
-            pmsg = &((*pmsg)->next);
-    }
-}
-
-static void freeMark(af_Activity *activity) {
-    if (activity->type == act_func && activity->func != nullptr && activity->mark != nullptr) {
-        auto func = (obj_funcFreeMask *)findAPI("obj_funcFreeMask", getObjectAPI(activity->func));
-        if (func != nullptr)
-            func(getObjectID(activity->func), activity->func, activity->mark);
-        activity->mark = nullptr;
-    }
-}
-
-/*
- * 函数名: popActivity
- * 目标: 释放Activity
- * 只有is_normal为false时才会检查释放mark
- */
-void popActivity(bool is_normal, af_Message *msg, af_Environment *env) {
-    if (env->activity->type == act_func || env->activity->type == act_top || env->activity->type == act_top_import) {
-        if (msg != nullptr && env->activity->return_first) {  // msg有内容, 并且设定了返回首位, 则清除msg内容, 并压入首位(压入的代码在下面)
-            if (EQ_STR(msg->type, "NORMAL")) {
-                gc_delObjectReference(*(af_Object **) msg->msg, env);
-                freeMessage(msg);
-                msg = nullptr;
-            }
-        } else if (env->activity->return_first) {  // msg无内容, 并且设定了返回首位, 则检查msg_down是否有normal, 有则清除
-            if (env->activity->msg_down != nullptr && EQ_STR(env->activity->msg_down->type, "NORMAL")) {
-                af_Message *tmp = getFirstMessage(env);
-                gc_delObjectReference(*(af_Object **) (tmp->msg), env);
-                freeMessage(tmp);
-            }
-        }
-
-        if (msg == nullptr && env->activity->return_first) {  // 如果首位
-            if (env->activity->return_obj == nullptr)
-                msg = makeERRORMessage(RUN_ERROR, RETURN_OBJ_NOT_FOUND_INFO, env);
-            else {
-                gc_addObjectReference(env->activity->return_obj, env);
-                msg = makeNORMALMessage(env->activity->return_obj, env);
-                env->activity->return_obj = nullptr;
-            }
-        }
-    }
-
-    if (msg != nullptr)
-        pushMessageDown(msg, env);
-
-    if (env->activity->type == act_top_import && /* import模式, 并且msg_down中有normal, 则把normal替换为belong */
-        env->activity->msg_down != nullptr && EQ_STR(env->activity->msg_down->type, "NORMAL")) {
-        af_Message *tmp = getFirstMessage(env);
-        gc_addObjectReference(env->activity->belong, env);
-        pushMessageDown(makeIMPORTMessage(env->activity->import_mark, env->activity->belong, env), env);  // 压入belong作为msg
-        pushMessageDown(tmp, env);
-    }
-
-    /* 正常情况下在执行完最后一个FuncBody后释放mark, 非正常情况(即最后一个FuncBody可能还没执行)则需要在此释放mark */
-    if (!is_normal)
-        freeMark(env->activity);  // 遇到非正常退出时, 释放`mark`
-
-    if (env->activity->type == act_top || env->activity->type == act_guardian) {// 顶层或gc/guardian层
-        runTopMessageProcess((env->activity->type == act_top), env);
-    } else {
-        connectMessage(&(env->activity->msg_down), env->activity->prev->msg_down);
-        env->activity->prev->msg_down = env->activity->msg_down;
-        env->activity->msg_down = nullptr;
-
-        /* popActivity必然设定process_msg_first */
-        env->activity->prev->process_msg_first++;
-    }
-
-    if (env->activity->type != act_top)
-        env->activity = freeActivity(env->activity, env);
-    else
-        freeActivityTop(env->activity);  // activity不被释放
-}
-
-static af_LiteralRegex *makeLiteralRegex(const char *pattern, const char *func, bool in_protect) {
-    af_Regex *rg = makeRegex(pattern, nullptr);
-    if (rg == nullptr)
-        return nullptr;
-
-    auto lr = calloc(1, af_LiteralRegex);
-    lr->rg = rg;
-    lr->pattern = strCopy(pattern);
-    lr->func = strCopy(func);
-    lr->in_protect = in_protect;
-    return lr;
-}
-
-static af_LiteralRegex *freeLiteralRegex(af_LiteralRegex *lr) {
-    af_LiteralRegex *next = lr->next;
-    freeRegex(lr->rg);
-    free(lr->func);
-    free(lr->pattern);
-    free(lr);
-    return next;
-}
-
-static void freeAllLiteralRegex(af_LiteralRegex *lr) {
-    while (lr != nullptr)
-        lr = freeLiteralRegex(lr);
-}
-
-bool pushLiteralRegex(const char *pattern, const char *func, bool in_protect, af_Environment *env) {
-    af_LiteralRegex *lr = makeLiteralRegex(pattern, func, in_protect);
-    if (lr == nullptr)
-        return false;
-    lr->next = env->lr;
-    env->lr = lr;
-    return true;
-}
-
-/*
- * 函数名: checkLiteralCode
- * 目标: 检查对象是否为字面量
- * 注意: func被写入函数名, 但不是复制式写入
- */
-bool checkLiteralCode(const char *literal, char **func, bool *in_protect, af_Environment *env) {
-    for (af_LiteralRegex *lr = env->lr; lr != nullptr; lr = lr->next) {
-        if (matchRegex(literal, lr->rg, nullptr) == 1) {
-            if (func != nullptr)
-                *func = lr->func;  // 不使用复制
-            if (in_protect != nullptr)
-                *in_protect = lr->in_protect;
-            return true;
-        }
-    }
-    return false;
-}
-
-static af_EnvironmentList *makeEnvironmentList(af_Environment *env) {
-    static size_t id = 0;
-    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
-
-    auto envl = calloc(1, af_EnvironmentList);
-    envl->env = env;
-
-    pthread_mutex_lock(&mutex);
-    envl->id = id;
-    id++;
-    pthread_mutex_unlock(&mutex);
-    return envl;
-}
-
-static bool freeEnvironmentList(af_EnvironmentList *envl, af_Environment *base) {
-    pthread_mutex_lock(&base->thread_lock);
-
-    if (envl->prev == nullptr) {
-        base->env_list = envl->next;
-    } else
-        envl->prev->next = envl->next;
-    if (envl->next != nullptr)
-        envl->next->prev = envl->prev;
-    free(envl);
-
-    pthread_mutex_unlock(&base->thread_lock);
-    return true;
-}
-
-bool freeEnvironmentListByEnv(af_Environment *env, af_Environment *base) {
-    pthread_mutex_lock(&base->thread_lock);
-
-    for (af_EnvironmentList *envl = base->env_list; envl != nullptr; envl = envl->next) {
-        if (envl->env == env) {
-            pthread_mutex_unlock(&base->thread_lock);
-            return freeEnvironmentList(envl, base);
-        }
-    }
-    pthread_mutex_unlock(&base->thread_lock);
-    return false;
-}
-
-void pushEnvironmentList(af_Environment *env, af_Environment *base) {
-    af_EnvironmentList *envl = makeEnvironmentList(env);
-    pthread_mutex_lock(&base->thread_lock);
-    envl->next = base->env_list;
-    base->env_list = envl;
-    pthread_mutex_unlock(&base->thread_lock);
-}
-
-af_ErrorInfo *makeErrorInfo(const char *type, const char *error, const char *note, FileLine line, FilePath path) {
-    auto ei = calloc(1, af_ErrorInfo);
-    ei->error_type = strCopy(type);
-    ei->error = strCopy(error);
-    pushErrorBacktracking(line, path, note, ei);
-    return ei;
-}
-
-void freeErrorInfo(af_ErrorInfo *ei, af_Environment *env){
-    free(ei->error_type);
-    free(ei->error);
-    if (ei->obj != nullptr)
-        gc_delObjectReference(ei->obj, env);
-    freeAllErrorBacktracking(ei->track);
-    free(ei);
-}
-
-static void fprintfNote(FILE *file, const char *note) {
-    char *ent = nullptr;
-    while(true) {
-        ent = const_cast<char *>(strchr(note, '\n'));
-        if (ent != nullptr)
-            *ent = NUL;
-        fprintf(file, "   #note %s\n", note);
-        if (ent == nullptr)  // 意味着是最后一部分`note`
-            break;
-        *ent = '\n';
-        note = ent + 1;
-    }
-}
-
-void fprintfErrorInfo(FILE *file, af_ErrorInfo *ei) {
-    fprintf(file, "Error Traceback (most recent call last):\n");
-    for (af_ErrorBacktracking *ebt = ei->track; ebt != nullptr; ebt = ebt->next) {
-        fprintf(file, "  File \"%s\", line %d\n", ebt->file, ebt->line);
-        if (ebt->note != nullptr)
-            fprintfNote(file, ebt->note);
-    }
-    fprintf(file, "%s: \"%s\"\n", ei->error_type, ei->error);
-    fflush(file);
-}
-
-static void fprintfNoteStderr(const char *note) {
-    char *ent = nullptr;
-    while(true) {
-        ent = const_cast<char *>(strchr(note, '\n'));
-        if (ent != nullptr)
-            *ent = NUL;
-        printf_stderr(0, "   #note %s\n", note);
-        if (ent == nullptr)  // 意味着是最后一部分`note`
-            break;
-        *ent = '\n';
-        note = ent + 1;
-    }
-}
-
-void fprintfErrorInfoStderr(af_ErrorInfo *ei) {
-    printf_stderr(0, "Error Traceback (most recent call last):\n");
-    for (af_ErrorBacktracking *ebt = ei->track; ebt != nullptr; ebt = ebt->next) {
-        printf_stderr(0, "  File \"%s\", line %d\n", ebt->file, ebt->line);
-        if (ebt->note != nullptr)
-            fprintfNoteStderr(ebt->note);
-    }
-    printf_stderr(0, "%s: \"%s\"\n", ei->error_type, ei->error);
-    fflush(stderr);
-}
-
-static void fprintfNoteStdout(const char *note) {
-    char *ent = nullptr;
-    while(true) {
-        ent = const_cast<char *>(strchr(note, '\n'));
-        if (ent != nullptr)
-            *ent = NUL;
-        printf_stdout(0, "   #note %s\n", note);
-        if (ent == nullptr)  // 意味着是最后一部分`note`
-            break;
-        *ent = '\n';
-        note = ent + 1;
-    }
-}
-
-void fprintfErrorInfoStdout(af_ErrorInfo *ei) {
-    printf_stdout(0, "Error Traceback (most recent call last):\n");
-    for (af_ErrorBacktracking *ebt = ei->track; ebt != nullptr; ebt = ebt->next) {
-        printf_stdout(0, "  File \"%s\", line %d\n", ebt->file, ebt->line);
-        if (ebt->note != nullptr)
-            fprintfNoteStdout(ebt->note);
-    }
-    printf_stdout(0, "%s: \"%s\"\n", ei->error_type, ei->error);
-    fflush(stdout);
-}
-
-static af_ErrorBacktracking *makeErrorBacktracking(FileLine line, FilePath file, const char *note) {
-    auto ebt = calloc(1, af_ErrorBacktracking);
-    ebt->line = line;
-    if (file == nullptr)
-        ebt->file = strCopy("unknown.aun.sys");
-    else
-        ebt->file = strCopy(file);
-    if (note != nullptr)
-        ebt->note = strCopy(note);
-    return ebt;
-}
-
-static af_ErrorBacktracking *freeErrorBacktracking(af_ErrorBacktracking *ebt) {
-    af_ErrorBacktracking *next = ebt->next;
-    free(ebt->note);
-    free(ebt->file);
-    free(ebt);
-    return next;
-}
-
-static void freeAllErrorBacktracking(af_ErrorBacktracking *ebt) {
-    while(ebt != nullptr) {
-        ebt = freeErrorBacktracking(ebt);
-    }
-}
-
-void pushErrorBacktracking(FileLine line, FilePath file, const char *note, af_ErrorInfo *ei) {
-    af_ErrorBacktracking *ebt = makeErrorBacktracking(line, file, note);
-    ebt->next = ei->track;
-    ei->track = ebt;
-}
-
-static char *getActivityInfoToBacktracking(af_Activity *activity){
-    char info[512 + CODE_STR_MAX_SIZE] = "";
-
-    /* strcat拼接的字符是可控的, 因此不需要使用安全函数 */
-    if (activity->type == act_guardian) {
-        strcat(info, "guardian-activity;");
-        return strCopy(info);
-    } else if (activity->type == act_top)
-        strcat(info, "top-activity;");
-    else if (activity->type == act_top_import)
-        strcat(info, "top-import-activity;");
-    else if (activity->is_execution)
-        strcat(info, "execution-activity;");
-    else if (activity->is_gc_call)
-        strcat(info, "gc-destruct-function-call-activity;");
-    else
-        strcat(info, "function-call-activity;");
-
-    switch (activity->status) {
-        case act_func_get:
-            strcat(info, "\nfunc-get;");
-            break;
-        case act_func_arg:
-            strcat(info, "\nfunc-arg;");
-            if (activity->run_in_func)
-                strcat(info, " run-in-function-var-space;");
-            break;
-        case act_func_normal:
-            strcat(info, "\nrun-code;");
-            if (activity->return_first)
-                strcat(info, " return-first-result;");
-            break;
-        default:
-            break;
-    }
-
-    if (activity->is_macro_call)
-        strcat(info, "\nmacro-call;");
-
-    if (activity->is_literal)
-        strcat(info, "\nliteral-call;");
-
-    if (activity->is_obj_func)
-        strcat(info, "\nobject-function-call;");
-
-    if (activity->optimization)
-        strcat(info, "\ntail-call-optimization;");
-
-    if (activity->bt_done != nullptr) {
-        char *code = codeToStr(activity->bt_done, 1);
-        if (code != nullptr) {
-            strcat(info, "\ncode: ");
-            strcat(info, code);
-            free(code);
-        }
-    }
-
-    return strCopy(info);
-}
-
-static char *getActivityTrackBackInfoToBacktracking(af_ActivityTrackBack *atb) {
-    char info[512] = "backtracking;";
-
-    /* strcat拼接的字符是可控的, 因此不需要使用安全函数 */
-    if (atb->is_execution)
-        strcat(info, "\nexecution-activity;");
-    else if (atb->is_gc_call)
-        strcat(info, "\ngc-destruct-function-call-activity;");
-    else
-        strcat(info, "\nfunction-call-activity;");
-
-
-    switch (atb->status) {
-        case act_func_get:
-            strcat(info, "\nfunc-get;");
-            break;
-        case act_func_arg:
-            strcat(info, "\nfunc-arg;");
-            if (atb->run_in_func)
-                strcat(info, " run-in-function-var-space;");
-            break;
-        case act_func_normal:
-            strcat(info, "\nrun-code;");
-            if (atb->return_first)
-                strcat(info, " return-first-result;");
-            break;
-        default:
-            break;
-    }
-
-    if (atb->is_macro_call)
-        strcat(info, "\nmacro-call;");
-
-    if (atb->is_literal)
-        strcat(info, "\nliteral-call;");
-
-    if (atb->is_obj_func)
-        strcat(info, "\nobject-function-call;");
-
-    if (atb->optimization)
-        strcat(info, "\ntail-call-optimization;");
-
-    return strCopy(info);
-}
-
-/**
- * 生成用于类型为IMPORT的Message的信息的数据
- * 注意: obj必须添加 gc_addReference
- * @param mark
- * @param obj
- * @param env
- * @return
- */
-af_ImportInfo *makeImportInfo(const char *mark, af_Object *obj, af_Environment *env){
-    auto ii = calloc(1, af_ImportInfo);
-    if (mark != nullptr)
-        ii->mark = strCopy(mark);
-    ii->obj = obj;
-    return ii;
-}
-
-void freeImportInfo(af_ImportInfo *ii, af_Environment *env){
-    free(ii->mark);
-    if (ii->obj != nullptr)
-        gc_delObjectReference(ii->obj, env);
-    free(ii);
-}
-
-/**
- * 创建守护器函数调用列表
- * 注意: obj和func 必须添加 gc_addReference
- * @param obj func的belong (可为nullptr)
- * @param func 调用的函数
- * @param env 运行环境
- * @return
- */
-static af_GuardianList *makeGuardianList(af_Object *obj, af_Object *func, af_Environment *env){
-    auto gl = calloc(1, af_GuardianList);
-    gl->obj = obj;
-    gl->func = func;
-    return gl;
-}
-
-static af_GuardianList *freeGuardianList(af_GuardianList *gl, af_Environment *env){
-    af_GuardianList *next = gl->next;
-    if (gl->obj != nullptr)
-        gc_delObjectReference(gl->obj, env);
-    gc_delObjectReference(gl->func, env);
-    free(gl);
-    return next;
-}
-
-static void freeAllGuardianList(af_GuardianList *gl, af_Environment *env){
-    while (gl != nullptr)
-        gl = freeGuardianList(gl, env);
-}
-
-void pushGuardianList(af_Object *obj, af_Object *func, paf_GuardianList &pal, af_Environment *env){
-    *pal = makeGuardianList(obj, func, env);
-    pal = &((*pal)->next);
-}
-
-af_GuardianList **contectGuardianList(af_GuardianList *new_gl, af_GuardianList **base) {
-    while ((*base) != nullptr)
-        base = &((*base)->next);
-    *base = new_gl;
-    while ((*base) != nullptr)
-        base = &((*base)->next);
-    return base;
-}
-
-void setGcMax(int32_t max, af_Environment *env) {
-    pthread_rwlock_wrlock(&env->esv->lock);
-    env->gc_max->num = max;
-    pthread_rwlock_unlock(&env->esv->lock);
-}
-
-void setGcRun(enum GcRunTime grt, af_Environment *env) {
-    pthread_rwlock_wrlock(&env->esv->lock);
-    env->gc_runtime->num = grt;
-    pthread_rwlock_unlock(&env->esv->lock);
-}
-
-int32_t getGcCount(af_Environment *env) {
-    pthread_rwlock_rdlock(&env->esv->lock);
-    int32_t res = env->gc_count->num;
-    pthread_rwlock_unlock(&env->esv->lock);
-    return res;
-}
-
-void GcCountAdd1(af_Environment *env) {
-    pthread_rwlock_wrlock(&env->esv->lock);
-    env->gc_count->num++;
-    pthread_rwlock_unlock(&env->esv->lock);
-}
-
-void GcCountToZero(af_Environment *env) {
-    pthread_rwlock_wrlock(&env->esv->lock);
-    env->gc_count->num = 0;
-    pthread_rwlock_unlock(&env->esv->lock);
-}
-
-void setArgc(int argc, af_Environment *env) {
-    pthread_rwlock_wrlock(&env->esv->lock);
-    env->argc->num = argc;
-    pthread_rwlock_unlock(&env->esv->lock);
-}
-
-int32_t getGcMax(af_Environment *env) {
-    pthread_rwlock_rdlock(&env->esv->lock);
-    int32_t res = env->gc_max->num;
-    pthread_rwlock_unlock(&env->esv->lock);
-    return res;
-}
-
-enum GcRunTime getGcRun(af_Environment *env) {
-    pthread_rwlock_rdlock(&env->esv->lock);
-    auto ret = (enum GcRunTime)env->gc_runtime->num;
-    pthread_rwlock_unlock(&env->esv->lock);
-    return ret;
-}
-int getArgc(af_Environment *env) {
-    pthread_rwlock_rdlock(&env->esv->lock);
-    int res = env->argc->num;
-    pthread_rwlock_unlock(&env->esv->lock);
-    return res;
-}
-
-af_Object *getCoreGlobal(af_Environment *env) {
-    return env->global;
-}
-
-af_Object *getGlobal(af_Environment *env) {
-    af_Activity *activity = env->activity;
-    for(NULL; activity != nullptr; activity = activity->prev) {
-        if (activity->type == act_top || activity->type == act_top_import) {
-            gc_addObjectReference(activity->belong, env);
-            return activity->belong;
-        }
-    }
-
-    gc_addObjectReference(env->global, env);
-    return env->global;
-}
-
-af_Object *getBelong(af_Environment *env) {
-    if (env == nullptr || env->activity == nullptr)
-        return nullptr;
-    return env->activity->belong;
-}
-
-FilePath getActivityFile(af_Environment *env){
-    if (env == nullptr || env->activity == nullptr)
-        return nullptr;
-    return env->activity->file;
-}
-
-FileLine getActivityLine(af_Environment *env){
-    if (env == nullptr || env->activity == nullptr)
-        return 0;
-    return env->activity->line;
-}
-
-char *getErrorType(af_ErrorInfo *ei) {
-    return ei->error_type;
-}
-
-char *getError(af_ErrorInfo *ei) {
-    return ei->error;
-}
-
-char *getImportMark(af_ImportInfo *ii) {
-    return ii->mark;
-}
-
-af_Object *getImportObject(af_ImportInfo *ii, af_Environment *env){
-    af_Object *obj = ii->obj;
-    if (obj == nullptr)
-        return nullptr;
-    ii->obj = nullptr;
-    return obj;
-}
-
-af_VarList *getRunVarSpaceList(af_Environment *env) {
-    return env->activity->run_varlist;
-}
-
-int isCoreExit(af_Environment *env) {
-    enum af_CoreStatus status = getCoreStatus(env);
-    if (status == core_exit)
-        return 1;
-    else if (status == core_stop)
-        return -1;
-    return 0;
-}
-
-bool getErrorStd(af_Environment *env) {
-    pthread_rwlock_rdlock(&env->esv->lock);
-    bool res = env->error_std->num != 0;  // true-stderr, false-stdout
-    pthread_rwlock_unlock(&env->esv->lock);
-    return res;
-}
-
-int32_t getCoreExitCode(af_Environment *env) {
-    pthread_rwlock_rdlock(&env->esv->lock);
-    int res = env->exit_code_->num;
-    pthread_rwlock_unlock(&env->esv->lock);
-    return res;
-}
-
-af_Object *getActivityFunc(af_Environment *env) {
-    if (env->activity == nullptr || env->activity->type == act_guardian)
-        return nullptr;
-    return env->activity->func;
-}
-
-size_t getEnviromentSonCount(af_Environment *env) {
-    pthread_mutex_lock(&env->thread_lock);
-    size_t res = 0;
-    for (af_EnvironmentList *envl = env->env_list; envl != nullptr; envl = envl->next)
-        res++;
-    pthread_mutex_unlock(&env->thread_lock);
-    return res;
-}
-
-enum af_CoreStatus getCoreStatus(af_Environment *env) {
-    pthread_mutex_lock(&env->status_lock);
-    enum af_CoreStatus res = env->status;
-    pthread_mutex_unlock(&env->status_lock);
-    return res;
-}
-
-/**
- * 线程外部 指示线程结束
- * @param env
- */
-void setEnviromentExit_out(af_Environment *env) {
-    pthread_mutex_lock(&env->thread_lock);
-    env->son_exit = true;
-    if (env->monitor != nullptr)
-        pthread_cond_signal(&env->monitor->cond);
-    pthread_mutex_unlock(&env->thread_lock);
-}
-
-bool isEnviromentExit(af_Environment *env) {
-    pthread_mutex_lock(&env->thread_lock);
-    bool res = env->son_exit == true;  // 线程外部指示线程结束
-    af_Environment *base = env->base;
-    pthread_mutex_unlock(&env->thread_lock);
-    if (res)
-        return true;
-    else if (env == base)
-        return false;
-
-    enum af_CoreStatus status = getCoreStatus(base);
-    res = status == core_exit || status == core_normal_gc;  // 主线程结束
-    return res;
-}
-
-/**
- * 等待次线程结束
- * @param env
- */
-void waitForEnviromentExit(af_Environment *env) {
-    pthread_mutex_lock(&env->status_lock);
-    env->status = core_exit;  // 不需要设置 exit_code
-    pthread_mutex_unlock(&env->status_lock);
-
-    if (env->gc_env != nullptr)
-        setEnviromentExit_out(env->gc_env);  // 设置 gc 线程退出
-
-    pthread_mutex_lock(&env->thread_lock);
-    while (env->env_list != nullptr) {
-        pthread_mutex_unlock(&env->thread_lock);
-        safeSleep(0.1);
-        pthread_mutex_unlock(&env->thread_lock);
-    }
-    pthread_mutex_unlock(&env->thread_lock);
-}

src/core/func.cpp

@@ -1,238 +0,0 @@
-#include "__func.hpp"
-
-/* FuncBody 创建与释放 */
-static af_FuncBody *makeFuncBody(enum af_FuncBodyType type, char **msg_type);
-
-/* msg_type 释放 */
-static void freeMsgType(char **msg_type);
-
-af_ArgCodeList *makeArgCodeList(af_Code *code, size_t size, bool free_code, bool run_in_func) {
-    auto acl = calloc(1, af_ArgCodeList);
-    acl->info = calloc_size(1, size);
-    acl->size = size;
-    acl->code = code;
-    acl->free_code = free_code;
-    acl->run_in_func = run_in_func;
-    return acl;
-}
-
-static af_ArgCodeList *freeArgCodeList(af_ArgCodeList *acl, af_Environment *env){
-    af_ArgCodeList *next = acl->next;
-    free(acl->info);
-    if (acl->free_code)
-        freeAllCode(acl->code);
-    if (acl->result != nullptr)
-        gc_delObjectReference(acl->result, env);
-    free(acl);
-    return next;
-}
-
-void freeAllArgCodeList(af_ArgCodeList *acl, af_Environment *env){
-    while (acl != nullptr)
-        acl = freeArgCodeList(acl, env);
-}
-
-af_ArgCodeList **pushArgCodeList(af_ArgCodeList **base, af_ArgCodeList *new_acl) {
-    while (*base != nullptr)
-        base = &((*base)->next);
-    *base = new_acl;
-
-    while (*base != nullptr)
-        base = &((*base)->next);
-    return base;
-}
-
-void *getArgCodeListData(af_ArgCodeList *acl) {
-    return acl->info;
-}
-
-af_Object *getArgCodeListResult(af_ArgCodeList *acl) {
-    return acl->result;
-}
-
-af_ArgList *makeArgList(const char *name, af_Object *obj){
-    auto arg_list = calloc(1, af_ArgList);
-    arg_list->name = strCopy(name);
-    arg_list->obj = obj;
-    return arg_list;
-}
-
-static af_ArgList *freeArgList(af_ArgList *al, af_Environment *env){
-    af_ArgList *next = al->next;
-    free(al->name);
-    if (al->obj != nullptr)
-        gc_delObjectReference(al->obj, env);
-    free(al);
-    return next;
-}
-
-void freeAllArgList(af_ArgList *al, af_Environment *env){
-    while (al != nullptr)
-        al = freeArgList(al, env);
-}
-
-af_ArgList **pushArgList(af_ArgList **base, af_ArgList *new_al) {
-    while (*base != nullptr)
-        base = &((*base)->next);
-    *base = new_al;
-
-    while (*base != nullptr)
-        base = &((*base)->next);
-    return base;
-}
-
-/**
- * af_ArgCodeList 转 af_ArgList
- * @param name 参数名
- * @param acl ArgCodeList
- * @param env 运行环境
- * @return
- */
-af_ArgList *makeArgListFromArgCodeList(const char *name, af_ArgCodeList *acl, af_Environment *env) {
-    af_Object *obj = getArgCodeListResult(acl);
-    gc_addObjectReference(obj, env);
-
-    af_ArgList *al = makeArgList(name, obj);
-    return al;
-}
-
-bool runArgList(af_ArgList *al, af_VarList *vsl, af_Environment *env){
-    for(NULL; al != nullptr; al = al->next) {
-        if (!makeVarToVarSpaceList(al->name, 3, 3, 3, al->obj, vsl,
-                                   env->activity->belong, env))
-            return false;
-    }
-    return true;
-}
-
-static af_FuncBody *makeFuncBody(enum af_FuncBodyType type, char **msg_type) {
-    auto fb = calloc(1, af_FuncBody);
-    fb->type = type;
-    fb->msg_type = msg_type;
-    return fb;
-}
-
-af_FuncBody *makeCodeFuncBody(af_Code *code, bool free_code, char **msg_type) {
-    af_FuncBody *fb = makeFuncBody(func_body_code, msg_type);
-    fb->code = code;
-    fb->free_code = free_code;
-    return fb;
-}
-
-af_FuncBody *makeImportFuncBody(af_Code *code, bool free_code, char **msg_type) {
-    af_FuncBody *fb = makeFuncBody(func_body_import, msg_type);
-    fb->code = code;
-    fb->free_code = free_code;
-    return fb;
-}
-
-af_FuncBody *makeDynamicFuncBody() {
-    af_FuncBody *fb = makeFuncBody(func_body_dynamic, nullptr);
-    return fb;
-}
-
-af_FuncBody *makeCFuncBody(DLC_SYMBOL(callFuncBody) c_func, char **msg_type) {
-    af_FuncBody *fb = makeFuncBody(func_body_c, msg_type);
-    fb->c_func = COPY_SYMBOL(c_func, callFuncBody);
-    return fb;
-}
-
-static void freeMsgType(char **msg_type) {
-    for (char *tmp = *msg_type; tmp != nullptr; tmp++)
-        free(tmp);
-    free(msg_type);
-}
-
-af_FuncBody *freeFuncBody(af_FuncBody *fb) {
-    af_FuncBody *next = fb->next;
-    if ((fb->type == func_body_code || fb->type == func_body_import) && fb->free_code)
-        freeAllCode(fb->code);
-    else if (fb->type == func_body_c)
-        FREE_SYMBOL(fb->c_func);
-
-    if (fb->msg_type != nullptr)
-        freeMsgType(fb->msg_type);
-    free(fb);
-    return next;
-}
-
-void freeAllFuncBody(af_FuncBody *fb) {
-    while (fb != nullptr)
-        fb = freeFuncBody(fb);
-}
-
-void pushFuncBody(af_FuncBody **base, af_FuncBody *body) {
-    while (*base != nullptr)
-        base = &((*base)->next);
-    *base = body;
-}
-
-af_FuncInfo *makeFuncInfo(enum af_FuncInfoScope scope, enum af_FuncInfoEmbedded embedded, bool is_macro, bool var_this, bool var_func){
-    auto fi = calloc(1, af_FuncInfo);
-    fi->scope = scope;
-    fi->embedded = embedded;
-    fi->is_macro = is_macro;
-    fi->var_this = var_this;
-    fi->var_func = var_func;
-    return fi;
-}
-
-void freeFuncInfo(af_FuncInfo *fi) {  // vsl是不释放的
-    freeAllFuncBody(fi->body);
-    free(fi);
-}
-
-af_FuncBody *makeCFuncBodyToFuncInfo(DLC_SYMBOL(callFuncBody) c_func, char **msg_type, af_FuncInfo *fi) {
-    af_FuncBody *fb = makeCFuncBody(c_func, msg_type);
-    pushFuncBody(&fi->body, fb);
-    return fb;
-}
-
-af_FuncBody *makeCodeFuncBodyToFuncInfo(af_Code *code, bool free_code, char **msg_type, af_FuncInfo *fi) {
-    af_FuncBody *fb = makeCodeFuncBody(code, free_code, msg_type);
-    pushFuncBody(&fi->body, fb);
-    return fb;
-}
-
-af_FuncBody *makeImportFuncBodyToFuncInfo(af_Code *code, bool free_code, char **msg_type, af_FuncInfo *fi) {
-    af_FuncBody *fb = makeImportFuncBody(code, free_code, msg_type);
-    pushFuncBody(&fi->body, fb);
-    return fb;
-}
-
-af_FuncBody *makeDynamicFuncBodyToFuncInfo(af_FuncInfo *fi) {
-    af_FuncBody *fb = makeDynamicFuncBody();
-    pushFuncBody(&fi->body, fb);
-    return fb;
-}
-
-bool pushDynamicFuncBody(af_FuncBody *new_fub, af_FuncBody *body) {
-    if (body == nullptr || body->next == nullptr || body->next->type != func_body_dynamic) {
-        freeAllFuncBody(new_fub);
-        return false;
-    }
-
-    if (new_fub == nullptr) {
-        body->next = freeFuncBody(body->next);  // 不添加任何新内容, 但释放func_body_dynamic
-    } else {
-        af_FuncBody **next = &new_fub;
-        while ((*next) != nullptr)
-            next = &((*next)->next);
-        *next = freeFuncBody(body->next);  // 把func_body_dynamic后的内容添加到new_fub的末尾
-        body->next = new_fub;
-    }
-
-    return true;
-}
-
-af_ArgCodeList *getArgCodeListNext(af_ArgCodeList *acl) {
-    return acl->next;
-}
-
-af_ArgList *getArgListNext(af_ArgList *al) {
-    return al->next;
-}
-
-bool getArgCodeListRunInFunc(af_ArgCodeList *acl) {
-    return acl->run_in_func;
-}

src/core/gc.cpp

@@ -1,670 +0,0 @@
-#include "aFunCore.hpp"
-#include "__object.hpp"
-#include "pthread.h"
-
-static void resetGC(af_Environment *env);
-
-/* gc 操控函数 */
-void gc_addObjectData(af_ObjectData *od, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    od->gc.info.reference = 1;
-    od->gc.prev = nullptr;
-    if (base->gc_factory->gc_ObjectData != nullptr)
-        base->gc_factory->gc_ObjectData->gc.prev = od;
-    od->gc.next = base->gc_factory->gc_ObjectData;
-    base->gc_factory->gc_ObjectData = od;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delObjectData(af_ObjectData *od, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((od)->gc.prev != nullptr)
-        (od)->gc.prev->gc.next = (od)->gc.next;
-    else
-        base->gc_factory->gc_ObjectData = (od)->gc.next;
-    if ((od)->gc.next != nullptr)
-        (od)->gc.next->gc.prev = (od)->gc.prev;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_addObjectDataReference(af_ObjectData *od, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    od->gc.info.reference++;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delObjectDataReference(af_ObjectData *od, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    od->gc.info.reference--;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_addObject(af_Object *obj, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    obj->gc.info.reference = 1;
-    obj->gc.prev = nullptr;
-    if (base->gc_factory->gc_Object != nullptr)
-        base->gc_factory->gc_Object->gc.prev = obj;
-    obj->gc.next = base->gc_factory->gc_Object;
-    base->gc_factory->gc_Object = obj;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delObject(af_Object *obj, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((obj)->gc.prev != nullptr)
-        (obj)->gc.prev->gc.next = (obj)->gc.next;
-    else
-        base->gc_factory->gc_Object = (obj)->gc.next;
-    if ((obj)->gc.next != nullptr)
-        (obj)->gc.next->gc.prev = (obj)->gc.prev;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_addObjectReference(af_Object *obj, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    obj->gc.info.reference++;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delObjectReference(af_Object *obj, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    obj->gc.info.reference--;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_addVar(af_Var *var, af_Environment *base) {
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    var->gc.info.reference = 1;
-    var->gc.prev = nullptr;
-    if (base->gc_factory->gc_Var != nullptr)
-        base->gc_factory->gc_Var->gc.prev = var;
-    var->gc.next = base->gc_factory->gc_Var;
-    base->gc_factory->gc_Var = var;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delVar(af_Var *var, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((var)->gc.prev != nullptr)
-        (var)->gc.prev->gc.next = (var)->gc.next;
-    else
-        base->gc_factory->gc_Var = (var)->gc.next;
-    if ((var)->gc.next != nullptr)
-        (var)->gc.next->gc.prev = (var)->gc.prev;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_addVarReference(af_Var *var, af_Environment *base) {
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    var->gc.info.reference++;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delVarReference(af_Var *var, af_Environment *base) {
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    var->gc.info.reference--;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-/**
- * 将 VarSpace 添加到 gc 链中
- * 只能由MakeVarSpace调用
- * 注意: 不上锁
- * @param vs
- * @param base
- */
-void gc_addVarSpace(af_VarSpace *vs, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    vs->gc.info.reference = 1;
-    vs->gc.prev = nullptr;
-    if (base->gc_factory->gc_VarSpace != nullptr)
-        base->gc_factory->gc_VarSpace->gc.prev = vs;
-    vs->gc.next = base->gc_factory->gc_VarSpace;
-    base->gc_factory->gc_VarSpace = vs;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delVarSpace(af_VarSpace *vs, af_Environment *base){
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((vs)->gc.prev != nullptr)
-        (vs)->gc.prev->gc.next = (vs)->gc.next;
-    else
-        base->gc_factory->gc_VarSpace = (vs)->gc.next;
-
-    if ((vs)->gc.next != nullptr)
-        (vs)->gc.next->gc.prev = (vs)->gc.prev;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_addVarSpaceReference(af_VarSpace *vs, af_Environment *base) {
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    vs->gc.info.reference++;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delVarSpaceReference(af_VarSpace *vs, af_Environment *base) {
-    base = base->base;  // 转换为主线程 Env
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    vs->gc.info.reference--;
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-void gc_delVarListReference(af_VarList *vsl, af_Environment *base) {
-    gc_delVarSpaceReference(vsl->vs, base);
-}
-
-/* gc_Factory 函数 */
-gc_Factory *makegGcFactory() {
-    auto factory = calloc(1, gc_Factory);
-
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    pthread_mutex_init(&factory->mutex, &attr);  // 声明为 gc 互斥锁
-    pthread_mutexattr_destroy(&attr);
-
-    return factory;
-}
-
-void freeGcFactory(struct gc_Factory *factory) {
-    pthread_mutex_destroy(&factory->mutex);
-    free(factory);
-}
-
-/* gcList 函数 */
-/* gcList 创建与释放 */
-static af_GcList *freeGcList(af_GcList *gl);
-
-af_GcList *makeGcList(enum af_GcListType type, void *data) {
-    auto gl = calloc(1, af_GcList);
-    gl->type = type;
-    gl->data = data;
-    assertWarningLog(data != nullptr, aFunCoreLogger, "GcList not data write.");
-    return gl;
-}
-
-static af_GcList *freeGcList(af_GcList *gl) {
-    af_GcList *next = gl->next;
-    free(gl);
-    return next;
-}
-
-void freeAllGcList(af_GcList *gl) {
-    while (gl != nullptr)
-        gl = freeGcList(gl);
-}
-
-af_GcList *pushGcList(enum af_GcListType type, void *data, af_GcList *base) {
-    af_GcList *next = makeGcList(type, data);
-    next->next = base;
-    return next;
-}
-
-/* 分析记录器函数 */
-/* 分析记录器 创建与释放 */
-static void makeAnalyzed(struct af_Object *obj, pgc_Analyzed &plist);
-static gc_Analyzed *freeAnalyzed(gc_Analyzed *base);
-static void freeAllAnalyzed(gc_Analyzed *base);
-
-// 关于gc_Analyzed为什么只需要记录Object的解释参见下文 (reachableObject)
-static void makeAnalyzed(struct af_Object *obj, pgc_Analyzed &plist) {
-    if (obj->gc.info.reachable)
-        return;
-
-    *plist = calloc(1, gc_Analyzed);
-    (*plist)->obj = obj;
-    plist = &((*plist)->next);
-}
-
-static gc_Analyzed *freeAnalyzed(gc_Analyzed *base) {
-    gc_Analyzed *next = base->next;
-    free(base);
-    return next;
-}
-
-static void freeAllAnalyzed(gc_Analyzed *base) {
-    while (base != nullptr)
-        base = freeAnalyzed(base);
-}
-
-/* gc 运行时函数 */
-/* 可达性分析函数 */
-static void reachableVar(struct af_Var *var, pgc_Analyzed &plist);
-static void reachableVarSpace(struct af_VarSpace *vs, pgc_Analyzed &plist);
-static void reachableVarSpaceList(struct af_VarList *vsl, pgc_Analyzed &plist);
-static void reachableObjectData(struct af_ObjectData *od, pgc_Analyzed &plist);
-static void reachableObject(struct af_Object *obj, pgc_Analyzed &plist);
-
-/* gc运行函数 */
-static void freeValue(af_Environment *env);
-static void reachable(af_Activity *activity, pgc_Analyzed &plist);
-static void iterLinker(af_Environment *env, pgc_Analyzed &plist);
-static void iterEnvironment(af_Environment *env, pgc_Analyzed &plist);
-static void checkDestruct(af_Environment *env, paf_GuardianList *pgl, pgc_Analyzed &plist);
-static void checkAnalyzed(pgc_Analyzed *analyzed, pgc_Analyzed &plist);
-
-// 使用 gc_Analyzed 目的是令可达性分析程序不需要使用递归
-// Object->OvjectData->VarSpace->Var; 仅允许单项调用, 不发生递归
-// 当VarSpace, Var和ObjectData需要调用Object时, 则使用gc_Analyzed, 创建需要调用的链
-// ObjectData可能要调用API, 因此其需要调用的对象是不确定的, 但只有Object需要gc_Analyzed
-// VarSpace和Var的调用是确定的, 他们不会往回调用除Object外的其他量
-// 所以gc_Analyzed记录Object就足够了
-static void reachableObject(struct af_Object *obj, pgc_Analyzed &plist) {
-    for(NULL; obj != nullptr && !obj->gc.info.reachable; obj = obj->belong) {
-        obj->gc.info.reachable = true;
-        pthread_rwlock_rdlock(&obj->lock);
-        if (!obj->data->gc.info.reachable)
-            reachableObjectData(obj->data, plist);
-        pthread_rwlock_unlock(&obj->lock);
-    }
-}
-
-static void reachableObjectData(struct af_ObjectData *od, pgc_Analyzed &plist) {  // 暂时不考虑API调用
-    if (od->gc.info.reachable)
-        return;
-
-    od->gc.info.reachable = true;
-
-    pthread_rwlock_rdlock(&od->lock);
-    reachableVarSpace(od->var_space, plist);
-    if (!od->base->gc.info.reachable)
-        makeAnalyzed(od->base, plist);
-
-    for (af_Inherit *ih = od->inherit; ih != nullptr; ih = getInheritNext(ih)) {
-        af_Object *obj = getInheritObject(ih);
-        af_VarSpace *vs = getInheritVarSpace(ih);
-        if (!obj->gc.info.reachable)
-            makeAnalyzed(obj, plist);
-
-        if (!vs->gc.info.reachable)
-            reachableVarSpace(vs, plist);
-    }
-
-    auto func = (obj_getGcList *)findAPI("obj_getGcList", od->api);
-    if (func != nullptr) {
-        af_GcList *gl = func(od->id.c_str(), od->base, od->data);
-        for (af_GcList *tmp = gl; tmp != nullptr; tmp = tmp->next) {
-            if (tmp->data == nullptr)
-                continue;
-
-            switch (tmp->type) {
-                case glt_obj:
-                    if (!tmp->obj->gc.info.reachable)
-                        makeAnalyzed(tmp->obj, plist);
-                    break;
-                case glt_var:
-                    reachableVar(tmp->var, plist);
-                    break;
-                case glt_vs:
-                    reachableVarSpace(tmp->vs, plist);
-                    break;
-                case glt_vsl:
-                    reachableVarSpaceList(tmp->vsl, plist);
-                    break;
-                default:
-                    break;
-            }
-        }
-        freeAllGcList(gl);
-    }
-
-    pthread_rwlock_unlock(&od->lock);
-}
-
-static void reachableVarSpace(struct af_VarSpace *vs, pgc_Analyzed &plist) {
-    if (vs->gc.info.reachable)
-        return;
-
-    vs->gc.info.reachable = true;
-
-    pthread_rwlock_rdlock(&vs->lock);
-    if (vs->belong != nullptr)
-        makeAnalyzed(vs->belong, plist);
-
-    for (auto var : vs->var) {
-        for (; var != nullptr; var = var->next)
-            reachableVar(var->var, plist);
-    }
-
-    pthread_rwlock_unlock(&vs->lock);
-}
-
-static void reachableVar(struct af_Var *var, pgc_Analyzed &plist) {
-    if (var->gc.info.reachable)
-        return;
-
-    var->gc.info.reachable = true;
-
-    pthread_rwlock_rdlock(&var->lock);
-    for (af_VarNode *vn = var->vn; vn != nullptr; vn = vn->next) {
-        if (!vn->obj->gc.info.reachable)
-            makeAnalyzed(vn->obj, plist);
-    }
-    pthread_rwlock_unlock(&var->lock);
-}
-
-static void reachableVarSpaceList(struct af_VarList *vsl, pgc_Analyzed &plist) {
-    for(NULL; vsl != nullptr; vsl = vsl->next) {
-        if (!vsl->vs->gc.info.reachable)
-            reachableVarSpace(vsl->vs, plist);
-    }
-}
-
-static void iterLinker(af_Environment *env, pgc_Analyzed &plist) {
-    reachableVarSpace(env->protect, plist);
-    if (env->global != nullptr)
-        reachableObject(env->global, plist);
-
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != nullptr; od = od->gc.next) {
-        if (od->gc.info.reference > 0 || od->gc.info.not_clear)
-            reachableObjectData(od, plist);
-    }
-
-    for (af_Object *obj = env->gc_factory->gc_Object; obj != nullptr; obj = obj->gc.next) {
-        if (obj->gc.info.reference > 0 || obj->gc.info.not_clear)
-            reachableObject(obj, plist);
-    }
-
-    for (af_VarSpace *vs = env->gc_factory->gc_VarSpace; vs != nullptr; vs = vs->gc.next) {
-        if (vs->gc.info.reference > 0 || vs->gc.info.not_clear)
-            reachableVarSpace(vs, plist);
-    }
-
-    for (af_Var *var = env->gc_factory->gc_Var; var != nullptr; var = var->gc.next) {
-        if (var->gc.info.reference > 0 || var->gc.info.not_clear)
-            reachableVar(var, plist);
-    }
-}
-
-static void iterEnvironment(af_Environment *env, pgc_Analyzed &plist) {
-    pthread_mutex_lock(&env->thread_lock);
-    if (env->result != nullptr)
-        reachableObject(env->result, plist);
-    pthread_mutex_unlock(&env->thread_lock);
-
-    reachable(env->activity, plist);
-}
-
-static void reachable(af_Activity *activity, pgc_Analyzed &plist) {
-    for(NULL; activity != nullptr; activity = activity->prev) {
-        if (activity->belong != nullptr)
-            reachableObject(activity->belong, plist);
-
-        reachableVarSpaceList(activity->run_varlist, plist);
-        if (activity->type == act_guardian) {  // gc不执行接下来的检查
-            for (af_GuardianList *gl = activity->gl; gl != nullptr; gl = gl->next) {
-                reachableObject(gl->func, plist);
-                if (gl->obj != nullptr)
-                    reachableObject(gl->obj, plist);
-            }
-        } else {
-
-            if (activity->func != nullptr)
-                reachableObject(activity->func, plist);
-
-            if (activity->return_obj != nullptr)
-                reachableObject(activity->return_obj, plist);
-
-            if (activity->parentheses_call != nullptr)
-                reachableObject(activity->parentheses_call, plist);
-
-            reachableVarSpaceList(activity->out_varlist, plist);
-            reachableVarSpaceList(activity->func_varlist, plist);
-            reachableVarSpaceList(activity->macro_varlist, plist);
-        }
-    }
-}
-
-static void checkAnalyzed(gc_Analyzed *analyzed, pgc_Analyzed &plist) {
-    for (gc_Analyzed *done = analyzed; done != nullptr; done = done->next)
-        reachableObject(done->obj, plist);
-}
-
-static void resetGC(af_Environment *env) {
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != nullptr; od = od->gc.next)
-        od->gc.info.reachable = false;
-
-    for (af_Object *obj = env->gc_factory->gc_Object; obj != nullptr; obj = obj->gc.next)
-        obj->gc.info.reachable = false;
-
-    for (af_VarSpace *vs = env->gc_factory->gc_VarSpace; vs != nullptr; vs = vs->gc.next)
-        vs->gc.info.reachable = false;
-
-    for (af_Var *var = env->gc_factory->gc_Var; var != nullptr; var = var->gc.next)
-        var->gc.info.reachable = false;
-}
-
-/**
- * 清理对象, 清除不可达的对象
- * 内部函数, 不上锁
- * @param env
- */
-static void freeValue(af_Environment *env) {
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData, *next; od != nullptr; od = next) {
-        next = od->gc.next;
-        if (!od->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "GC free ObjectData: %p", od);
-            freeObjectData(od, env);
-        }
-    }
-
-    for (af_Object *obj = env->gc_factory->gc_Object, *next; obj != nullptr; obj = next) {
-        next = obj->gc.next;
-        if (!obj->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "GC free Object: %p", obj);
-            freeObject(obj, env);
-        }
-    }
-
-    for (af_VarSpace *vs = env->gc_factory->gc_VarSpace, *next; vs != nullptr; vs = next) {
-        next = vs->gc.next;
-        if (!vs->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "GC free VarSpace: %p [%p]", vs, vs->belong);
-            freeVarSpace(vs, env);
-        }
-    }
-
-    for (af_Var *var = env->gc_factory->gc_Var, *next; var != nullptr; var = next) {
-        next = var->gc.next;
-        if (!var->gc.info.reachable) {
-            writeTrackLog(aFunCoreLogger, "GC free Var: %p [%s] %d", var, var->name, var->gc.info.reference);
-            freeVar(var, env);
-        }
-    }
-}
-
-/**
- * 检查对象是否有析构函数
- * 内部函数, 不上锁
- * @param env
- * @param pgl
- * @param plist
- * @return
- */
-static void checkDestruct(af_Environment *env, paf_GuardianList *pgl, pgc_Analyzed &plist) {
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != nullptr; od = od->gc.next) {
-        if (!od->gc.info.reachable && !od->gc.done_destruct) {
-            af_Object *func = findObjectAttributesByObjectData(mg_gc_destruct, nullptr, od, env);
-            if (func == nullptr)
-                continue;
-            od->gc.done_destruct = true;
-
-            pthread_rwlock_rdlock(&od->lock);
-            af_Object *base = od->base;
-            pthread_rwlock_unlock(&od->lock);
-            gc_addObjectReference(base, env);
-
-            pushGuardianList(base, func, *pgl, env);
-            reachableObjectData(od, plist);
-        }
-    }
-}
-
-af_GuardianList *gc_RunGC(af_Environment *base) {
-    gc_Analyzed *analyzed = nullptr;
-    af_GuardianList *gl = nullptr;
-    pgc_Analyzed plist = &analyzed;
-    paf_GuardianList pgl = ≷
-    base = base->base;  // 切换到主线程
-
-    writeTrackLog(aFunCoreLogger, "gc start");
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    resetGC(base);
-    iterLinker(base, plist);  // 临时量分析 (临时量都是通过reference标记的)
-    iterEnvironment(base, plist);
-
-    pthread_mutex_lock(&base->thread_lock);
-    for (af_EnvironmentList *envl = base->env_list; envl != nullptr; envl = envl->next)
-        iterEnvironment(envl->env, plist);
-    pthread_mutex_unlock(&base->thread_lock);
-
-    checkAnalyzed(analyzed, plist);  // 先处理剩余的Object
-    checkDestruct(base, &pgl, plist);  // 在检查析构
-    checkAnalyzed(analyzed, plist);  // 在处理 checkDestruct 时产生的新引用
-
-    freeValue(base);
-    freeAllAnalyzed(analyzed);
-    writeTrackLog(aFunCoreLogger, "gc end");
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-    return gl;
-}
-
-/**
- * 检查所有ObjectData的析构函数
- * 非内部函数, 会上锁
- * @param env
- * @param pgl
- * @return
- */
-paf_GuardianList checkAllDestruct(af_Environment *env, paf_GuardianList pgl) {
-    af_Environment *base = env->base;
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    for (af_ObjectData *od = base->gc_factory->gc_ObjectData; od != nullptr; od = od->gc.next) {
-        if (!od->gc.done_destruct) {
-            af_Object *func = findObjectAttributesByObjectData(mg_gc_destruct, nullptr, od, env);
-            if (func == nullptr)
-                continue;
-            od->gc.done_destruct = true;
-
-            pthread_rwlock_rdlock(&od->lock);
-            af_Object *base_obj = od->base;
-            pthread_rwlock_unlock(&od->lock);
-            gc_addObjectReference(base_obj, env);
-            pushGuardianList(base_obj, func, pgl, env);
-        }
-    }
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-    return pgl;
-}
-
-/**
- * 释放所有ObjectData的 void *Data
- * @param env
- */
-void gc_freeAllValueData(af_Environment *env) {
-    af_Environment *base = env->base;
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    for (af_ObjectData *od = base->gc_factory->gc_ObjectData; od != nullptr; od = od->gc.next) {
-        freeObjectDataData(od, env);
-    }
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-/**
- * 释放所有的Value
- * @param env
- */
-void gc_freeAllValue(af_Environment *env) {
-    af_Environment *base = env->base;
-
-    pthread_mutex_lock(&base->gc_factory->mutex);
-    for (af_ObjectData *od = base->gc_factory->gc_ObjectData; od != nullptr; od = base->gc_factory->gc_ObjectData)
-        freeObjectData(od, env);
-
-    for (af_Object *obj = base->gc_factory->gc_Object; obj != nullptr; obj = base->gc_factory->gc_Object)
-        freeObject(obj, env);
-
-    for (af_VarSpace *vs = base->gc_factory->gc_VarSpace; vs != nullptr; vs = base->gc_factory->gc_VarSpace)
-        freeVarSpace(vs, env);
-
-    for (af_Var *var = base->gc_factory->gc_Var; var != nullptr; var = base->gc_factory->gc_Var)
-        freeVar(var, env);
-    pthread_mutex_unlock(&base->gc_factory->mutex);
-}
-
-/**
- * Debug用的函数
- * 不上锁
- * @param env
- */
-void printGCByCore(af_Environment *env) {
-    bool success = true;
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != nullptr; od = od->gc.next) {
-        if (od->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "GC Reference ObjectData(%p): %d", od, od->gc.info.reference);
-            success = false;
-        } else
-            writeTrackLog(aFunCoreLogger, "GC Reference ObjectData(%p): %d", od, od->gc.info.reference);
-    }
-
-    for (af_Object *obj = env->gc_factory->gc_Object; obj != nullptr; obj = obj->gc.next) {
-        if (obj->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "GC Reference Object(%p->%p): %d", obj, obj->data, obj->gc.info.reference);
-            success = false;
-        } else
-            writeTrackLog(aFunCoreLogger, "GC Reference Object(%p->%p): %d", obj, obj->data, obj->gc.info.reference);
-    }
-
-    for (af_VarSpace *vs = env->gc_factory->gc_VarSpace; vs != nullptr; vs = vs->gc.next) {
-        if (vs->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "GC Reference VarSpace(%p): %d", vs, vs->gc.info.reference);
-            success = false;
-        } else
-            writeTrackLog(aFunCoreLogger, "GC Reference VarSpace(%p): %d", vs, vs->gc.info.reference);
-    }
-
-    for (af_Var *var = env->gc_factory->gc_Var; var != nullptr; var = var->gc.next) {
-        if (var->gc.info.reference != 0) {
-            writeWarningLog(aFunCoreLogger, "GC Reference Var(%p): %d", var, var->gc.info.reference);
-            success = false;
-        } else
-            writeTrackLog(aFunCoreLogger, "GC Reference Var(%p): %d", var, var->gc.info.reference);
-    }
-
-    if (!success)
-        writeWarningLog(aFunCoreLogger, "GC Reference warning.");
-}

src/core/global_obj.cpp

@@ -1,77 +0,0 @@
-#include <iostream>
-#include "aFunCore.hpp"
-#include "__object.hpp"
-
-typedef struct GlobalObjectData GlobalObjectData;
-struct GlobalObjectData {
-    af_VarSpace *share;
-};
-
-const std::string global_id = "global-object";
-
-static void initGOD(af_Object *obj, GlobalObjectData *data, af_Environment *env) {
-    data->share = makeVarSpace(obj, 3, 2, 0, env);
-    gc_delVarSpaceReference(data->share, env);
-}
-
-static void freeGOD(GlobalObjectData *god, af_Object  *obj, af_Environment *env) {  // NOLINT 必备参数
-    god->share = nullptr;
-}
-
-static size_t getSize(const std::string &id, af_Object *obj) {  // NOLINT 必备参数
-    /* 不需要检查 id */
-    return sizeof(GlobalObjectData);
-}
-
-static void initData(const std::string &id, af_Object *obj, GlobalObjectData *data, af_Environment *env) {
-    if (id == global_id)
-        initGOD(obj, data, env);
-}
-
-static void freeData(const std::string &id, af_Object *obj, GlobalObjectData *data, af_Environment *env) {
-    if (id == global_id)
-        freeGOD(data, obj, env);
-}
-
-static af_GcList *getGcList(const std::string &id, af_Object *obj, GlobalObjectData *data) {  // NOLINT 必备参数
-    if (id != global_id)
-        return nullptr;
-
-    if (data->share != nullptr)
-        return pushGcList(glt_vs, data->share, nullptr);
-    return nullptr;
-}
-
-
-static af_VarSpace *getShareVS(const std::string &id, af_Object *obj) {
-    if (id != global_id)
-        return nullptr;
-    return ((GlobalObjectData *)getObjectData(obj))->share;
-}
-
-af_Object *makeGlobalObject(af_Environment *env) {
-    af_ObjectAPI *api = makeObjectAPI();
-    DLC_SYMBOL(objectAPIFunc) get_size = MAKE_SYMBOL(getSize, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) init_data = MAKE_SYMBOL(initData, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) free_data = MAKE_SYMBOL(freeData, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) get_share_vs = MAKE_SYMBOL(getShareVS, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcList, objectAPIFunc);
-    if (addAPI(get_size, "obj_getDataSize", api) != 1)
-        return nullptr;
-    if (addAPI(init_data, "obj_initData", api) != 1)
-        return nullptr;
-    if (addAPI(free_data, "obj_destructData", api) != 1)
-        return nullptr;
-    if (addAPI(get_share_vs, "obj_getShareVarSpace", api) != 1)
-        return nullptr;
-    if (addAPI(get_gl, "obj_getGcList", api) != 1)
-        return nullptr;
-
-    FREE_SYMBOL(get_size);
-    FREE_SYMBOL(init_data);
-    FREE_SYMBOL(free_data);
-    FREE_SYMBOL(get_share_vs);
-    FREE_SYMBOL(get_gl);
-
-    return makeObject(global_id, true, api, true, nullptr, true, nullptr, env);
-}

src/core/lexical.cpp

@@ -1,455 +0,0 @@
-/*
- * 文件名: lexical
- * 目标: aFunlang词法分析
- */
-#include <cctype>
-#include "aFunCore.hpp"
-#include "__parser.hpp"
-#include "parserl_warning_error.h"
-
-#ifndef isascii
-#define isascii(c) (((c) & ~0x7f) == 0)
-#endif
-
-#define isignore(ch) (isascii(ch) && (iscntrl(ch) || isspace(ch) || (ch) == ','))  /* 被忽略的符号 */
-#define iselement(ch) (!isascii(ch) || isgraph(ch))  /* 可以作为element的符号 */
-
-#define DEL_TOKEN (0)
-#define FINISH_TOKEN (-1)
-#define CONTINUE_TOKEN (1)
-#define ERROR_TOKEN (-2)
-
-#define printLexicalError(info, parser) do { \
-    writeErrorLog(aFunCoreLogger, "[Lexical] %s:%d %s", (parser)->reader->file, (parser)->reader->line, (info ## Log)); \
-    printf_stderr(0, "[%s] %s:%d : %s\n", HT_aFunGetText(lexical_n, "Lexical"), (parser)->reader->file, \
-                  (parser)->reader->line, info ## Console); \
-    (parser)->is_error = true; /* 错误标记在Parser而非Lexical中, Lexical的异常表示lexical停止运行 */ \
-} while(0)
-
-#define printLexicalWarning(info, parser) do { \
-    writeWarningLog(aFunCoreLogger, "[Lexical] %s:%d %s", (parser)->reader->file, (parser)->reader->line, (info ## Log)); \
-    printf_stderr(0, "[%s] %s:%d : %s\n", HT_aFunGetText(lexical_n, "Lexical"), (parser)->reader->file, \
-                  (parser)->reader->line, info ## Console); \
-} while(0)
-
-static void setLexicalLast(af_LexicalStatus status, af_TokenType token, af_Parser *parser) {
-    parser->lexical->status = status;
-    parser->lexical->last = parser->reader->read - parser->reader->buf;
-    parser->lexical->token = token;
-}
-
-/*
- * 函数族: done系列 (doneXXX)
- * 目标: 用于把转台xxx转换为其他状态
- * 返回值: 1 正常
- * 返回值: 0 遇到错误, 仍可继续
- * 返回值: -1 正常, 不可继续 -> 必须设置 setLexicalLast
- * 返回值: -2 遇到错误, 不可继续
- * 注意: 函数使用前不在检查`status`是否正确
- */
-
-/*
- * 状态机图:
- * [lex_begin]
- *     -> NUL -> (lex_nul)
- *     -> ALL_PREFIX -> [lex_prefix] # return FINISH_TOKEN
- *     -> ! -> (lex_prefix_block_p)
- *     -> @ -> (lex_prefix_block_b)
- *     -> # -> (lex_prefix_block_c)
- *     -> ( -> [lex_lp] # return FINISH_TOKEN
- *     -> [ -> [lex_lb] # return FINISH_TOKEN
- *     -> { -> [lex_lc] # return FINISH_TOKEN
- *     -> ) -> [lex_rp] # return FINISH_TOKEN
- *     -> ] -> [lex_rb] # return FINISH_TOKEN
- *     -> } -> [lex_rc] # return FINISH_TOKEN
- *     -> ; -> (lex_comment_before)
- *     -> isignore(ch) -> [lex_space]
- *     -> | -> (lex_element_long)
- *     -> iselement(ch) -> [lex_element]
- */
-
-static int doneBegin(char ch, af_Parser *parser) {
-    if (ch == NUL) {
-        setLexicalLast(lex_nul, TK_EOF, parser);
-        return FINISH_TOKEN;
-    } else if (strchr(ALL_PREFIX, ch)) {  /* 属于前缀 */
-        setLexicalLast(lex_prefix, TK_PREFIX, parser);
-        return FINISH_TOKEN;
-    } else if (strchr("!@#", ch)) {
-        switch (ch) {
-            case '!':
-                parser->lexical->status = lex_prefix_block_p;
-                return 1;
-            case '@':
-                parser->lexical->status = lex_prefix_block_b;
-                return 1;
-            case '#':
-                parser->lexical->status = lex_prefix_block_c;
-                return 1;
-            default:
-                writeFatalErrorLog(aFunCoreLogger, EXIT_FAILURE, "Switch illegal characters");
-                return ERROR_TOKEN;
-        }
-    } else if (strchr("([{)]}", ch)) { /* 括号 */
-        switch (ch) {
-            case '(':
-                setLexicalLast(lex_lp, TK_LP, parser);
-                return FINISH_TOKEN;
-            case '[':
-                setLexicalLast(lex_lb, TK_LB, parser);
-                return FINISH_TOKEN;
-            case '{':
-                setLexicalLast(lex_lc, TK_LC, parser);
-                return FINISH_TOKEN;
-            case ')':
-                setLexicalLast(lex_rp, TK_RP, parser);
-                return FINISH_TOKEN;
-            case ']':
-                setLexicalLast(lex_rb, TK_RB, parser);
-                return FINISH_TOKEN;
-            case '}':
-                setLexicalLast(lex_rc, TK_RC, parser);
-                return FINISH_TOKEN;
-            default:
-                writeFatalErrorLog(aFunCoreLogger, EXIT_FAILURE, "Switch illegal characters");
-                return ERROR_TOKEN;
-        }
-    } else if (ch == ';') {
-        parser->lexical->status = lex_comment_before;
-        return 1;
-    } else if (isignore(ch)) {  // 空白符或控制字符被忽略
-        setLexicalLast(lex_space, TK_SPACE, parser);
-        return 1;
-    } else if (ch == '|') {
-        parser->lexical->status = lex_element_long;
-        return 1;
-    } else if (iselement(ch)) {  // 除空格外的可见字符
-        setLexicalLast(lex_element_short, TK_ELEMENT_SHORT, parser);
-        return 1;
-    }
-    printLexicalError(IllegalChar, parser);
-    return DEL_TOKEN;
-}
-
-/*
- * 状态机图:
- * [lex_prefix_block_p] -> ( -> [lex_lp] # return FINISH_TOKEN
- * [lex_prefix_block_b] -> ( -> [lex_lb] # return FINISH_TOKEN
- * [lex_prefix_block_c] -> ( -> [lex_lc] # return FINISH_TOKEN
- * [lex_prefix_block_p] -> ) -> [lex_rp] # return FINISH_TOKEN
- * [lex_prefix_block_b] -> ) -> [lex_rb] # return FINISH_TOKEN
- * [lex_prefix_block_c] -> ) -> [lex_rc] # return FINISH_TOKEN
- */
-static int donePrefixBlock(char ch, af_Parser *parser) {
-    if (ch == '(') {
-        switch (parser->lexical->status) {
-            case lex_prefix_block_p:
-                setLexicalLast(lex_lp, TK_LP, parser);
-                return FINISH_TOKEN;
-            case lex_prefix_block_b:
-                setLexicalLast(lex_lb, TK_LB, parser);
-                return FINISH_TOKEN;
-            case lex_prefix_block_c:
-                setLexicalLast(lex_lc, TK_LC, parser);
-                return FINISH_TOKEN;
-            default:
-                writeFatalErrorLog(aFunCoreLogger, EXIT_FAILURE, "Switch illegal characters");
-                return ERROR_TOKEN;
-        }
-    } else if (ch == ')') {
-        switch (parser->lexical->status) {
-            case lex_prefix_block_p:
-                setLexicalLast(lex_rp, TK_RP, parser);
-                return FINISH_TOKEN;
-            case lex_prefix_block_b:
-                setLexicalLast(lex_rb, TK_RB, parser);
-                return FINISH_TOKEN;
-            case lex_prefix_block_c:
-                setLexicalLast(lex_rc, TK_RC, parser);
-                return FINISH_TOKEN;
-            default:
-                writeFatalErrorLog(aFunCoreLogger, EXIT_FAILURE, "Switch illegal characters");
-                return ERROR_TOKEN;
-        }
-    }
-    printLexicalError(IllegalChar, parser);
-    return DEL_TOKEN;
-}
-
-/*
- * 状态机图:
- * [lex_comment_before]
- *      -> '\n' || NUL -> [lex_uni_comment_end] # return FINISH_TOKEN
- *      -> ; -> (lex_mutli_comment) # mutli_comment = 0
- *      -> other -> (lex_uni_comment)
- */
-static int doneCommentBefore(char ch, af_Parser *parser) {
-    if (ch == '\n' || ch == NUL) {
-        setLexicalLast(lex_uni_comment_end, TK_COMMENT, parser);
-        return FINISH_TOKEN;
-    } else if (ch == ';') {  // 多行注释
-        parser->lexical->status = lex_mutli_comment;
-        parser->lexical->mutli_comment = 0;
-        return 1;
-    }
-    parser->lexical->status = lex_uni_comment;
-    return 1;
-}
-
-/*
- * 状态机图:
- * [lex_uni_comment]
- *      -> '\n' || NUL -> [lex_uni_comment_end] # return FINISH_TOKEN
- *      -> other -> (lex_uni_comment)
- */
-static int doneUniComment(char ch, af_Parser *parser) {
-    if (ch == '\n' || ch == NUL) {
-        setLexicalLast(lex_uni_comment_end, TK_COMMENT, parser);
-        return FINISH_TOKEN;
-    }
-    parser->lexical->status = lex_uni_comment;
-    return 1;
-}
-
-/*
- * 状态机图:
- * [lex_mutli_comment]
- *      -> NUL -> [lex_mutli_comment_end] # return FINISH_TOKEN; [warning]
- *      -> ; -> (lex_mutli_comment_end_before)
- *      -> other -> (lex_mutli_comment)
- */
-static int doneMutliComment(char ch, af_Parser *parser) {
-    if (ch == NUL) {
-        parser->lexical->status = lex_mutli_comment_end;
-        printLexicalWarning(IncompleteFile, parser);
-        return FINISH_TOKEN;
-    } else if (ch == ';')
-        parser->lexical->status = lex_mutli_comment_end_before;
-    else
-        parser->lexical->status = lex_mutli_comment;
-    return 1;
-}
-
-/*
- * 状态机图:
- * [lex_mutli_comment_end_before]
- *      -> NUL -> [lex_mutli_comment_end] # return FINISH_TOKEN; [warning]
- *      -> ; -> (lex_mutli_comment) # mutli_comment++;
- *      -> = ->
- *              mutli_comment == 0 -> [lex_mutli_comment_end] # return FINISH_TOKEN
- *              else -> (lex_mutli_comment)# mutli_comment--;
- */
-static int doneMutliCommentBeforeEnd(char ch, af_Parser *parser) {
-    if (ch == NUL) {
-        printLexicalWarning(IncompleteFile, parser);
-        setLexicalLast(lex_mutli_comment_end, TK_COMMENT, parser);
-        return FINISH_TOKEN;
-    } else if (ch == ';') {
-        /* 嵌套注释 */
-        parser->lexical->mutli_comment++;
-        parser->lexical->status = lex_mutli_comment;
-    } else if (ch == '=') {
-        if (parser->lexical->mutli_comment == 0) {
-            /* 注释结束 */
-            setLexicalLast(lex_mutli_comment_end, TK_COMMENT, parser);
-            return FINISH_TOKEN;
-        } else {
-            /* 嵌套注释 */
-            parser->lexical->mutli_comment--;
-            parser->lexical->status = lex_mutli_comment;
-        }
-    }
-    parser->lexical->status = lex_mutli_comment;
-    return 1;
-}
-
-/*
- * 状态机图:
- * [lex_element_long]
- *      -> NUL -> error
- *      -> | -> [lex_element_long_end]
- *      -> other -> (lex_element_long)
- */
-static int doneElementLong(char ch, af_Parser *parser) {
-    if (ch == '|') {  // 结束符
-        setLexicalLast(lex_element_long_end, TK_ELEMENT_LONG, parser);
-        return 1;
-    } else if (ch == NUL) {
-        printLexicalError(IncompleteFile, parser);
-        return ERROR_TOKEN;
-    }
-    parser->lexical->status = lex_element_long;
-    return 1;
-}
-
-/*
- * 状态机图:
- * [lex_element_long]
- *      -> | -> (lex_element_long)
- *      -> other -> [lex_element_long_end] # return FINISH_TOKEN
- */
-static int doneElementLongEnd(char ch, af_Parser *parser) {
-    if (ch == '|') {  // ||表示非结束
-        parser->lexical->status = lex_element_long;
-        return 1;
-    }
-    parser->lexical->status = lex_element_long_end;
-    return FINISH_TOKEN;
-}
-
-/*
- * 状态机图:
- * [lex_element_short]
- *      -> !strchr("!@#([{}]);,", ch) && iselement(ch) -> (lex_element_short)
- *      -> other -> (lex_element_short) # return FINISH_TOKEN
- */
-static int doneElementShort(char ch, af_Parser *parser) {
-    if (!strchr("!@#([{}]);,", ch) && iselement(ch)) {  // 除空格外的可见字符 (不包括NUL)
-        setLexicalLast(lex_element_short, TK_ELEMENT_SHORT, parser);
-        return 1;
-    }
-    parser->lexical->status = lex_element_short;
-    return FINISH_TOKEN;
-}
-
-/*
- * 状态机图:
- * [lex_space]
- *      -> ch != NUL && isignore(ch) -> (lex_space)
- *      -> other -> (lex_space) # return FINISH_TOKEN
- */
-static int doneSpace(char ch, af_Parser *parser) {
-    if (ch != NUL && isignore(ch)) {
-        setLexicalLast(lex_space, TK_SPACE, parser);
-        return 1;
-    }
-    parser->lexical->status = lex_space;
-    return FINISH_TOKEN;
-}
-
-/*
- * 函数名: getTokenFromLexical
- * 目标: 获取Lexical的TokenType以及相关值
- */
-af_TokenType getTokenFromLexical(char **text, af_Parser *parser) {
-    af_TokenType tt;
-    int re;
-    parser->lexical->status = lex_begin;
-    parser->lexical->last = 0;
-
-    if (parser->lexical->is_end) {
-        *text = nullptr;
-        return TK_EOF;
-    } else if (parser->lexical->is_error || parser->reader->read_error) {  /* lexical和reader出现异常后不再执行 */
-        *text = nullptr;
-        return TK_ERROR;
-    }
-
-    while (true) {
-        char ch = getChar(parser->reader);
-        if (parser->reader->read_error) {
-            *text = nullptr;
-            return TK_ERROR;
-        }
-
-        if (isascii(ch) && iscntrl(ch) && !isspace(ch) && ch != NUL)  // ascii 控制字符
-            printLexicalWarning(IncludeControlChar, parser);
-
-        switch (parser->lexical->status) {
-            case lex_begin:
-                re = doneBegin(ch, parser);
-                break;
-            case lex_prefix_block_p:
-            case lex_prefix_block_b:
-            case lex_prefix_block_c:
-                re = donePrefixBlock(ch, parser);
-                break;
-            case lex_comment_before:
-                re = doneCommentBefore(ch, parser);
-                break;
-            case lex_element_long:
-                re = doneElementLong(ch, parser);
-                break;
-            case lex_mutli_comment:
-                re = doneMutliComment(ch, parser);
-                break;
-            case lex_uni_comment:
-                re = doneUniComment(ch, parser);
-                break;
-            case lex_mutli_comment_end_before:
-                re = doneMutliCommentBeforeEnd(ch, parser);
-                break;
-            case lex_space:
-                re = doneSpace(ch, parser);
-                break;
-            case lex_element_short:
-                re = doneElementShort(ch, parser);
-                break;
-            case lex_element_long_end:
-                re = doneElementLongEnd(ch, parser);
-                break;
-            default:
-                writeFatalErrorLog(aFunCoreLogger, EXIT_FAILURE, "Switch illegal characters");
-                re = ERROR_TOKEN;
-                break;
-        }
-
-        if (re == ERROR_TOKEN) {
-            tt = TK_ERROR;
-            *text = nullptr;
-            break;
-        } else if (re == DEL_TOKEN) {  // 删除该token, 继续执行
-            char *word = readWord(parser->lexical->last, parser->reader);
-            free(word);
-            parser->lexical->status = lex_begin;
-            parser->lexical->last = 0;
-            continue;
-        } else if (re == FINISH_TOKEN) {
-            char *word = readWord(parser->lexical->last, parser->reader);
-            if (word == nullptr) {
-                tt = TK_ERROR;
-                *text = nullptr;
-                break;
-            }
-
-            tt = parser->lexical->token;
-
-            if (tt == TK_ELEMENT_SHORT || tt == TK_PREFIX)
-                *text = word;
-            else if (tt == TK_ELEMENT_LONG) {
-                char *new_str = NEW_STR(STR_LEN(word) - 2);  // 去除收尾|
-
-                bool flat = false;
-                char *p = word + 1;
-                size_t count = 0;
-                for(NULL; *p != NUL; p++) {
-                    if (*p == '|' && !flat) {  // 跳过第一个 `|`, 如果是末尾|则自然跳过, 若不是则在遇到第二个`|`时写入数据
-                        flat = true; /* count不需要递增 */
-                        continue;
-                    } else if (*p != '|' && flat)  // 遇到错误
-                        break;
-                    else
-                        flat = false;
-                    new_str[count] = *p;
-                    count++;
-                }
-
-                *text = strCopy(new_str);
-                free(word);
-                free(new_str);
-            } else
-                free(word);
-
-            if (tt == TK_SPACE || tt == TK_COMMENT) {
-                parser->lexical->status = lex_begin;
-                parser->lexical->last = 0;
-                continue;
-            } else if (tt == TK_EOF)
-                parser->lexical->is_end = true;
-
-            break;
-        }
-    }
-
-    return tt;
-}

src/core/monitor.cpp

@@ -1,51 +0,0 @@
-#include "__monitor.hpp"
-
-static void *monitorProgress(void *m);
-
-af_Monitor *makeMonitor(af_Environment *env) {
-    auto monitor = calloc(1, af_Monitor);
-    monitor->env = env;
-    pthread_mutex_init(&monitor->lock, nullptr);
-    pthread_cond_init(&monitor->cond, nullptr);
-
-    env->monitor = monitor;
-    pthread_create(&monitor->thread, nullptr, monitorProgress, monitor);
-    return monitor;
-}
-
-void freeMonitor(af_Environment *env) {
-    af_Monitor *monitor = env->monitor;
-
-    pthread_mutex_lock(&monitor->lock);
-    monitor->exit = true;
-    pthread_mutex_unlock(&monitor->lock);
-    pthread_cond_signal(&monitor->cond);
-
-    pthread_join(monitor->thread, nullptr);
-
-    pthread_mutex_lock(&env->thread_lock);
-    pthread_cond_destroy(&monitor->cond);
-    pthread_mutex_destroy(&monitor->lock);
-    free(monitor);
-    env->monitor = nullptr;
-    pthread_mutex_unlock(&env->thread_lock);
-}
-
-static void *monitorProgress(void *m) {
-    af_Monitor *monitor = (af_Monitor *)m;
-    af_Environment *env = monitor->env;
-    pthread_mutex_lock(&monitor->lock);
-    while (true) {
-        if (isEnviromentExit(env)) {
-            pthread_mutex_lock(&monitor->env->status_lock);
-            monitor->env->status = core_exit;
-            pthread_mutex_unlock(&monitor->env->status_lock);
-        }
-
-        pthread_cond_wait(&monitor->cond, &monitor->lock);
-        if (monitor->exit)
-            break;
-    }
-    pthread_mutex_unlock(&monitor->lock);
-    return nullptr;
-}

src/core/object.cpp

@@ -1,534 +0,0 @@
-#include "__object.hpp"
-#include "tool.hpp"
-#include "core_init.hpp"
-
-
-/* ObjectData API 创建与释放 */
-static af_ObjectAPINode *makeObjectAPINode(DLC_SYMBOL(objectAPIFunc) func, const char *api_name);
-static af_ObjectAPINode *freeObjectAPINode(af_ObjectAPINode *apin);
-static void freeAllObjectAPINode(af_ObjectAPINode *apin);
-
-/* ObjectData API 管理函数 */
-static af_ObjectAPINode *findObjectDataAPINode(const char *api_name, af_ObjectData *od);
-static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, const char *api_name, af_ObjectData *od);
-
-
-af_Object *makeObject(const std::string &id, bool free_api, af_ObjectAPI *api, bool allow_inherit, af_Object *belong,
-                      bool free_inherit, af_Inherit *inherit, af_Environment *env){
-    enum af_CoreStatus status = getCoreStatus(env);
-
-    if (api == nullptr) {
-        api = makeObjectAPI();
-        free_api = true;
-    }
-
-    af_Inherit *ih = nullptr;
-    if (inherit != nullptr)
-        ih = inherit;
-    else {
-        free_inherit = true;
-        if (env->global != nullptr)
-            ih = makeInherit(env->global);
-        else if (status != core_creat)
-            writeFatalErrorLog(aFunCoreLogger, 1, "Make object inherit null");
-    }
-
-    if (belong == nullptr) {
-        if (env->activity != nullptr)
-            belong = env->activity->belong;
-        else if (status == core_init)  // init模式生成: global
-            belong = env->global;
-        else if (status != core_creat)  // 只有creat可以使用belong=nullptr
-            writeFatalErrorLog(aFunCoreLogger, 1, "Make object belong null");
-    }
-
-    auto obj = calloc(1, af_Object);
-    auto od = calloc(1, af_ObjectData);
-
-    obj->belong = nullptr;
-    od->base = obj;
-    obj->data = od;
-    od->id = id;
-
-    od->api = api;
-    od->free_api = free_api;
-
-    od->allow_inherit = allow_inherit;
-    od->inherit = nullptr;
-
-    auto func = (obj_getDataSize *)findAPI("obj_getDataSize", api);
-    if (func != nullptr)
-        od->size = func(id, obj);
-    else
-        od->size = 0;
-
-    if (od->size != 0)
-        od->data = calloc_size(1, od->size);
-
-    pthread_rwlock_init(&od->lock, nullptr);
-    pthread_rwlock_init(&obj->lock, nullptr);
-
-    obj->belong = belong;
-    obj->data->inherit = ih;
-    obj->data->free_inherit = free_inherit;
-
-    od->var_space = makeVarSpace(obj, 3, 2, 0, env);
-    gc_addObjectData(od, env->base);
-    gc_addObject(obj, env->base);
-
-    if (obj->data->size != 0) {  // 要在 add_object 之后再运行 init
-        auto init = (obj_initData *)findAPI("obj_initData", obj->data->api);
-        if (init != nullptr)
-            init(id, obj, obj->data->data, env);
-    }
-
-    gc_delVarSpaceReference(od->var_space, env);
-    gc_delObjectDataReference(od, env);
-    return obj;
-}
-
-/*
- * 函数名: freeObjectDataData
- * 目标: 释放ObjectData的void *data, 仅GC函数可用
- * 对外API中, 创建对象的基本单位都是af_Object, 无法直接操控af_ObjectData
- */
-void freeObjectDataData(af_ObjectData *od, af_Environment *env) {
-    pthread_rwlock_rdlock(&od->lock);
-    if (od->size == 0) {
-        pthread_rwlock_unlock(&od->lock);
-        return;
-    }
-    auto func = (obj_destructData *)findAPI("obj_destructData", od->api);
-    if (func != nullptr)
-        func(od->id, od->base, od->data, env);
-    od->size = 0;
-    free(od->data);
-    pthread_rwlock_unlock(&od->lock);
-}
-
-/*
- * 函数名: freeObjectData
- * 目标: 释放ObjectData, 仅GC函数可用
- * 对外API中, 创建对象的基本单位都是af_Object, 无法直接操控af_ObjectData
- */
-void freeObjectData(af_ObjectData *od, af_Environment *env) {
-    if (od->size != 0) {
-        auto func = (obj_destructData * )findAPI("obj_destructData", od->api);
-        if (func != nullptr)
-            func(od->id, od->base, od->data, env);
-    }
-
-    free(od->data);
-    if (od->free_api)
-        freeObjectAPI(od->api);
-    if (od->free_inherit)
-        freeAllInherit(od->inherit);
-    gc_delObjectData(od, env);
-    pthread_rwlock_destroy(&od->lock);
-    free(od);
-}
-
-void freeObject(af_Object *obj, af_Environment *env) {
-    gc_delObject(obj, env);
-    pthread_rwlock_destroy(&obj->lock);
-    free(obj);
-}
-
-void *getObjectData(af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *od = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    pthread_rwlock_rdlock(&od->lock);
-    void *data = od->data;
-    pthread_rwlock_unlock(&od->lock);
-
-    return data;
-}
-
-af_Object *getBelongObject(af_Object *object){
-    pthread_rwlock_wrlock(&object->lock);
-    af_Object *belong = (object->belong == nullptr ? object : object->belong);
-    pthread_rwlock_unlock(&object->lock);
-    return belong;
-}
-
-af_Inherit *makeInherit(af_Object *obj) {
-    if (!isObjectAllowInherit(obj))
-        return nullptr;
-
-    auto func = (obj_getShareVarSpace *)findAPI("obj_getShareVarSpace", getObjectAPI(obj));
-    af_VarSpace *vs;
-    if (func == nullptr)
-        return nullptr;
-
-    if ((vs = func(getObjectID(obj), obj)) == nullptr)
-        return nullptr;
-
-    auto ih = calloc(1, af_Inherit);
-    ih->vs = vs;
-    ih->obj = obj;  // 调用API获取vs
-    pthread_rwlock_init(&ih->lock, nullptr);
-    return ih;
-}
-
-/**
- * 压入Inherit到末尾
- * 注意: 不上锁
- * @param base
- * @param new
- * @return
- */
-af_Inherit **pushInherit(af_Inherit **base, af_Inherit *new_ih) {
-    while ((*base) != nullptr)
-        base = &((*base)->next);
-    *base = new_ih;
-    while ((*base) != nullptr)
-        base = &((*base)->next);
-    return base;
-}
-
-static af_Inherit *freeInherit(af_Inherit *ih) {
-    af_Inherit *next = ih->next;  // vs一定是被gc托管的
-    pthread_rwlock_destroy(&ih->lock);
-    free(ih);
-    return next;
-}
-
-void freeAllInherit(af_Inherit *ih) {
-    while (ih != nullptr)
-        ih = freeInherit(ih);
-}
-
-bool checkPosterity(af_Object *base, af_Object *posterity) {
-    pthread_rwlock_rdlock(&posterity->lock);
-    af_ObjectData *data = posterity->data;
-    pthread_rwlock_unlock(&posterity->lock);
-
-    for (af_Inherit *ih = getObjectInherit(base); ih != nullptr; ih = getInheritNext(ih)) {
-        af_Object *obj = getInheritObject(ih);
-        pthread_rwlock_rdlock(&obj->lock);
-        if (obj->data == data) {
-            pthread_rwlock_unlock(&obj->lock);
-            return true;
-        }
-        pthread_rwlock_unlock(&obj->lock);
-    }
-
-    return false;
-}
-
-static af_ObjectAPINode *makeObjectAPINode(DLC_SYMBOL(objectAPIFunc) func, const char *api_name) {
-    if (func == nullptr)
-        return nullptr;
-
-    auto apin = calloc(1, af_ObjectAPINode);
-    apin->api = COPY_SYMBOL(func, objectAPIFunc);
-    apin->name = strCopy(api_name);
-    return apin;
-}
-
-static af_ObjectAPINode *freeObjectAPINode(af_ObjectAPINode *apin) {
-    af_ObjectAPINode *next = apin->next;
-    FREE_SYMBOL(apin->api);
-    free(apin->name);
-    free(apin);
-    return next;
-}
-
-static void freeAllObjectAPINode(af_ObjectAPINode *apin) {
-    while (apin != nullptr)
-        apin = freeObjectAPINode(apin);
-}
-
-af_ObjectAPI *makeObjectAPI() {
-    auto api = calloc(1, af_ObjectAPI);
-    pthread_rwlock_init(&api->lock, nullptr);
-    return api;
-}
-
-void freeObjectAPI(af_ObjectAPI *api) {
-    for (auto & i : api->node)
-        freeAllObjectAPINode(i);
-    pthread_rwlock_destroy(&api->lock);
-    free(api);
-}
-
-/*
- * 函数名: addAPIToObjectData
- * 目标: 从DLC中获取函数并写入api
- * 若已存在api则返回0且不作修改
- * 若dlc中不存在指定函数则返回-1且不作修改
- * 操作成功返回1
- */
-int addAPI(DLC_SYMBOL(objectAPIFunc) func, const char *api_name, af_ObjectAPI *api) {
-    time33_t index = time33(api_name) % API_HASHTABLE_SIZE;
-
-    pthread_rwlock_wrlock(&api->lock);
-    af_ObjectAPINode **pNode = &api->node[index];
-
-    for(NULL; *pNode != nullptr; pNode = &((*pNode)->next)) {
-        if (EQ_STR((*pNode)->name, api_name)) {
-            pthread_rwlock_unlock(&api->lock);
-            return 0;
-        }
-    }
-
-    *pNode = makeObjectAPINode(func, api_name);
-
-    int res = -1;
-    if (*pNode != nullptr) {
-        api->count++;
-        res = 1;
-    }
-
-    pthread_rwlock_unlock(&api->lock);
-    return res;
-}
-
-objectAPIFunc *findAPI(const char *api_name, af_ObjectAPI *api) {
-    time33_t index = time33(api_name) % API_HASHTABLE_SIZE;
-    objectAPIFunc *data = nullptr;
-    pthread_rwlock_rdlock(&api->lock);
-
-    for (af_ObjectAPINode *node = api->node[index]; node != nullptr; node = node->next) {
-        if (EQ_STR(node->name, api_name)) {
-            data = GET_SYMBOL(node->api);
-            break;
-        }
-    }
-
-    pthread_rwlock_unlock(&api->lock);
-    return data;
-}
-
-/*
- * 函数名: addAPIToObjectData
- * 目标: 从DLC中获取函数并写入api
- * 若已存在api则返回0且不作修改
- * 若dlc中不存在指定函数则返回-1且不作修改
- * 操作成功返回1
- */
-static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, const char *api_name,
-                              af_ObjectData *od) {
-    time33_t index = time33(api_name) % API_HASHTABLE_SIZE;
-
-    pthread_rwlock_rdlock(&od->lock);
-    af_ObjectAPI *api = od->api;
-    pthread_rwlock_unlock(&od->lock);
-
-    pthread_rwlock_wrlock(&api->lock);
-    af_ObjectAPINode **pNode = &api->node[index];
-    for(NULL; *pNode != nullptr; pNode = &((*pNode)->next)) {
-        if (EQ_STR((*pNode)->name, api_name)) {
-            pthread_rwlock_unlock(&api->lock);
-            return 0;
-        }
-    }
-
-    *pNode = makeObjectAPINode(func, api_name);
-
-    int res = -1;
-    if (*pNode != nullptr) {
-        api->count++;
-        res = 1;
-    }
-
-    pthread_rwlock_unlock(&api->lock);
-    return res;
-}
-
-static af_ObjectAPINode *findObjectDataAPINode(const char *api_name, af_ObjectData *od) {
-    time33_t index = time33(api_name) % API_HASHTABLE_SIZE;
-
-    pthread_rwlock_rdlock(&od->lock);
-    af_ObjectAPI *api = od->api;
-    pthread_rwlock_unlock(&od->lock);
-
-    af_ObjectAPINode *data = nullptr;
-    pthread_rwlock_rdlock(&api->lock);
-
-    for (af_ObjectAPINode *node = api->node[index]; node != nullptr; node = node->next) {
-        if (EQ_STR(node->name, api_name)) {
-            data = node;
-            break;
-        }
-    }
-
-    pthread_rwlock_unlock(&api->lock);
-    return data;
-}
-
-/*
- * 函数名: findObjectDataAPINode
- * 目标: 从DLC中获取函数并写入Object的API
- */
-int addAPIToObject(DLC_SYMBOL(objectAPIFunc) func, const char *api_name, af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    return addAPIToObjectData(func, api_name, data);
-}
-
-/*
- * 函数名: findObjectAPI
- * 目标: 从Object中获取指定api的函数指针
- */
-objectAPIFunc *findObjectAPI(const char *api_name, af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    af_ObjectAPINode *node = findObjectDataAPINode(api_name, data);
-    if (node == nullptr)
-        return nullptr;
-    return GET_SYMBOL(node->api);
-}
-
-af_Object *findObjectAttributes(const char *name, af_Object *visitor, af_Object *obj, af_Environment *env){
-    af_Var *var = findVarFromVarSpace(name, visitor, getObjectVarSpace(obj));
-
-    if (var != nullptr)
-        return findVarNode(var, nullptr, env);
-
-    for (af_Inherit *ih = getObjectInherit(obj); ih != nullptr; ih = getInheritNext(ih)) {
-        var = findVarFromVarSpace(name, visitor, getInheritVarSpace(ih));  // 搜索共享变量空间
-        if (var != nullptr)
-            return findVarNode(var, nullptr, env);
-    }
-
-    return nullptr;
-}
-
-/**
- * 添加属性到Object中
- * 注意: 必须保证 obj 又被 gc 引用
- */
-bool setObjectAttributes(const char *name, char p_self, char p_posterity, char p_external, af_Object *attributes,
-                         af_Object *obj, af_Object *visitor, af_Environment *env){
-    return makeVarToVarSpace(name, p_self, p_posterity, p_external, attributes, getObjectVarSpace(obj), visitor, env);
-}
-
-/**
- * 获得指定对象的属性, 自动添加 gc_addReference
- * @param name
- * @param visitor
- * @param od
- * @return
- */
-af_Object *findObjectAttributesByObjectData(const char *name, af_Object *visitor, af_ObjectData *od, af_Environment *env){
-    pthread_rwlock_rdlock(&od->lock);
-    af_Var *var = findVarFromVarSpace(name, visitor, od->var_space);
-    af_Inherit *ih = od->inherit;
-    pthread_rwlock_unlock(&od->lock);
-
-    if (var != nullptr)
-        return findVarNode(var, nullptr, env);
-
-    for(NULL; ih != nullptr; ih = getInheritNext(ih)) {
-        var = findVarFromVarSpace(name, visitor, getInheritVarSpace(ih));  // 搜索共享变量空间
-        if (var != nullptr)
-            return findVarNode(var, nullptr, env);
-    }
-
-    return nullptr;
-}
-
-const std::string &getObjectID(af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    pthread_rwlock_rdlock(&data->lock);
-    const std::string &id = data->id;
-    pthread_rwlock_unlock(&data->lock);
-
-    return id;
-}
-
-af_ObjectAPI *getObjectAPI(af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    pthread_rwlock_rdlock(&data->lock);
-    af_ObjectAPI *api = data->api;
-    pthread_rwlock_unlock(&data->lock);
-
-    return api;
-}
-
-af_Inherit *getObjectInherit(af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    pthread_rwlock_rdlock(&data->lock);
-    af_Inherit *ih = data->inherit;
-    pthread_rwlock_unlock(&data->lock);
-
-    return ih;
-}
-
-af_VarSpace *getObjectVarSpace(af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    pthread_rwlock_rdlock(&data->lock);
-    af_VarSpace *vs = data->var_space;
-    pthread_rwlock_unlock(&data->lock);
-
-    return vs;
-}
-
-af_Inherit *getInheritNext(af_Inherit *ih) {
-    pthread_rwlock_rdlock(&ih->lock);
-    af_Inherit *next = ih->next;
-    pthread_rwlock_unlock(&ih->lock);
-    return next;
-}
-
-af_Object *getInheritObject(af_Inherit *ih) {
-    pthread_rwlock_rdlock(&ih->lock);
-    af_Object *obj = ih->obj;
-    pthread_rwlock_unlock(&ih->lock);
-    return obj;
-}
-
-af_VarSpace *getInheritVarSpace(af_Inherit *ih) {
-    pthread_rwlock_rdlock(&ih->lock);
-    af_VarSpace *vs = ih->vs;
-    pthread_rwlock_unlock(&ih->lock);
-    return vs;
-}
-
-ObjAPIUint getAPICount(af_ObjectAPI *api) {
-    pthread_rwlock_rdlock(&api->lock);
-    ObjAPIUint res = api->count;
-    pthread_rwlock_unlock(&api->lock);
-    return res;
-}
-
-void objectSetAllowInherit(af_Object *obj, bool allow) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    pthread_rwlock_rdlock(&data->lock);
-    data->allow_inherit = allow;
-    pthread_rwlock_unlock(&data->lock);
-}
-
-bool isObjectAllowInherit(af_Object *obj) {
-    pthread_rwlock_rdlock(&obj->lock);
-    af_ObjectData *data = obj->data;
-    pthread_rwlock_unlock(&obj->lock);
-
-    pthread_rwlock_rdlock(&data->lock);
-    bool res = data->allow_inherit;
-    pthread_rwlock_unlock(&data->lock);
-
-    return res;
-}

src/core/parser.cpp

@@ -1,275 +0,0 @@
-/*
- * 文件名: parser.c
- * 目标: __parser.h中结构体的相关函数
- */
-
-#include "aFunCore.hpp"
-#include "tool.hpp"
-#include "__parser.hpp"
-
-static af_Lexical *makeLexical();
-static void freeLexical(af_Lexical *lex);
-static af_Syntactic *makeSyntactic();
-static void freeSyntactic(af_Syntactic *syntactic);
-static bool getStdinSignalFunc();
-
-af_Parser *makeParser(ConstFilePath file, DLC_SYMBOL(readerFunc) read_func, DLC_SYMBOL(destructReaderFunc) destruct_func,
-                      size_t data_size){
-    auto parser = calloc(1, af_Parser);
-    parser->reader = makeReader(1, file, read_func, destruct_func, data_size);
-    parser->lexical = makeLexical();
-    parser->syntactic = makeSyntactic();
-    return parser;
-}
-
-void freeParser(af_Parser *parser) {
-    freeReader(parser->reader);
-    freeLexical(parser->lexical);
-    freeSyntactic(parser->syntactic);
-    free(parser);
-}
-
-void initParser(af_Parser *parser) {
-    initReader(parser->reader);
-}
-
-static af_Lexical *makeLexical() {
-    auto lex = calloc(1, af_Lexical);
-    lex->status = lex_begin;
-    return lex;
-}
-
-static void freeLexical(af_Lexical *lex) {
-    free(lex);
-}
-
-static af_Syntactic *makeSyntactic() {
-    auto syntactic = calloc(1, af_Syntactic);
-    return syntactic;
-}
-
-static void freeSyntactic(af_Syntactic *syntactic) {
-    free(syntactic->text);
-    free(syntactic);
-}
-
-/* makeParser函数封装 */
-#define printReaderError(info, parser, stream) do { \
-    writeErrorLog(aFunCoreLogger, "[Reader] %s:%d %s", (parser)->reader->file, (parser)->reader->line, (info ## Log)); \
-    printf_std##stream(0, "[%s] %s:%d : %s\n", HT_aFunGetText(reader_n, "Reader"), (parser)->reader->file, \
-                  (parser)->reader->line, info ## Console); \
-    (parser)->is_error = true; /* 错误标记在Parser而非Lexical中, Lexical的异常表示lexical停止运行 */ \
-} while(0)
-
-struct readerDataString {
-    af_Parser *parser;
-    const char *str;
-    bool free_str;
-    size_t index;
-    size_t len;
-};
-
-static size_t readFuncString(struct readerDataString *data, char *dest, size_t len, int *mode) {
-    if (data->index == data->len)  // 读取到末尾
-        return 0;
-
-    if (data->index + len > data->len) {  // 超出长度范围
-        len = data->len - data->index;
-        *mode = READER_MODE_FINISHED;
-    }
-    memcpy(dest, data->str + data->index, len);
-    data->index += len;
-    return len;
-}
-
-static void destructFunc(struct readerDataString *data) {
-    if (data->free_str) {
-        char *tmp = const_cast<char *>(data->str);
-        free(tmp);
-    }
-}
-
-static void initStringReader(af_Parser *parser, const char *str, bool free_str, struct readerDataString *data) {
-    data->str = str;
-    data->free_str = free_str;
-    data->len = strlen(str);
-    data->parser = parser;
-}
-
-af_Parser *makeParserByString(ConstFilePath name, const char *str, bool free_str){
-    DLC_SYMBOL(readerFunc) read_func = MAKE_SYMBOL(readFuncString, readerFunc);
-    DLC_SYMBOL(destructReaderFunc) destruct = MAKE_SYMBOL(destructFunc, destructReaderFunc);
-    af_Parser *parser = makeParser(name, read_func, destruct, sizeof(struct readerDataString));
-    initStringReader(parser, str, free_str, (struct readerDataString *)parser->reader->data);
-    initParser(parser);
-    FREE_SYMBOL(read_func);
-    FREE_SYMBOL(destruct);
-    return parser;
-}
-
-struct readerDataFile {
-    af_Parser *parser;
-    FILE *file;
-    bool no_first;
-};
-
-static size_t readFuncFile(struct readerDataFile *data, char *dest, size_t len, int *mode) {
-    if (!data->no_first) {
-        data->no_first = true;
-        char ch;
-        if (fread(&ch, sizeof(char), 1, data->file) != 1) {
-            *mode = READER_MODE_FINISHED;
-            return 0;
-        }
-
-        if (ch == (char)0xEF) {
-            /* 处理BOM编码 */
-            char ch_[2];
-            if (fread(ch_, sizeof(char), 2, data->file) != 2 || ch_[0] != (char)0xBB || ch_[1] != (char)0xBF) {
-                printReaderError(BOMError, data->parser, err);
-                *mode = READER_MODE_ERROR;
-                return 0;
-            }
-            writeTrackLog(aFunCoreLogger, "Parser utf-8 with BOM");
-        } else {
-            ungetc(ch, data->file);
-            writeTrackLog(aFunCoreLogger, "Parser utf-8 without BOM");
-        }
-    }
-
-    size_t len_r =  fread(dest, sizeof(char), len, data->file);
-    if (CLEAR_FERROR(data->file)) {  // ferror在feof前执行
-        *mode = READER_MODE_ERROR;
-        printReaderError(FileIOError, data->parser, err);
-    } else if (feof(data->file))
-        *mode = READER_MODE_FINISHED;
-    return len_r;
-}
-
-static void destructFile(struct readerDataFile *data) {
-    if (data->file != nullptr)
-        fileClose(data->file);
-}
-
-static void initFileReader(af_Parser *parser, FILE *file, struct readerDataFile *data) {
-    data->file = file;
-    data->parser = parser;
-}
-
-af_Parser *makeParserByFile(ConstFilePath path){
-    FILE *file = fileOpen(path, "rb");
-    if (file == nullptr) {
-        writeErrorLog(aFunCoreLogger, "File open error: %s", path);
-        return nullptr;
-    } else
-        writeTrackLog(aFunCoreLogger, "File: %s", path);
-
-    DLC_SYMBOL(readerFunc) read_func = MAKE_SYMBOL(readFuncFile, readerFunc);
-    DLC_SYMBOL(destructReaderFunc) destruct = MAKE_SYMBOL(destructFile, destructReaderFunc);
-    af_Parser *parser = makeParser(path, read_func, destruct, sizeof(struct readerDataString));
-    initFileReader(parser, file, (struct readerDataFile *)parser->reader->data);
-    initParser(parser);
-    FREE_SYMBOL(read_func);
-    FREE_SYMBOL(destruct);
-    return parser;
-}
-
-typedef void (*HandleFunc) (int);
-struct readerDataStdin {
-    af_Parser *parser;
-    bool no_first;
-
-    HandleFunc sig_int;
-    HandleFunc sig_term;
-
-    char *data;
-    size_t index;
-    size_t len;
-};
-
-static bool getStdinSignalFunc() {
-    return aFunGetSignal(SIGINT) || aFunGetSignal(SIGTERM);
-}
-
-static size_t readFuncStdin(struct readerDataStdin *data, char *dest, size_t len, int *mode) {
-    if (data->index == data->len) {  // 读取内容
-        if (CLEAR_STDIN()) {
-            printReaderError(StdinError, data->parser, err);
-            *mode = READER_MODE_ERROR;
-            return 0;
-        }
-
-        if (data->no_first)
-            fputs("\r.... ", stdout);
-        else {
-            fclear_stdin();
-            fputs("\r>>>> ", stdout);
-        }
-        fflush(stdout);
-        data->no_first = true;
-        free(data->data);
-
-        /* 在Linux平台, 只用当数据写入stdin缓冲行时checkStdin才true */
-        /* 在Windows平台则是根据读取的最后一个字符是否为\n或者是否有按键按下来确定缓冲区是否有内容 */
-        while (!checkStdin()) {  // 无内容则一直循环等到
-            if (getStdinSignalFunc()) {  // 设置了中断函数, 并且该函数返回0
-                writeErrorLog(aFunCoreLogger, "Interrupt");
-                printf_stdout(0, "%s\n", HT_aFunGetText(Interrupt_n, "Interrupt"));
-                data->parser->is_error = true;
-                *mode = READER_MODE_ERROR;
-                return 0;
-            }
-        }
-
-        int ch = fgetc_stdin();
-        if (ch == '\n' || ch == EOF) {
-            /* 读取结束 */
-            *mode = READER_MODE_FINISHED;
-            return 0;
-        }
-
-        fungetc_stdin(ch);
-
-        /* 读取内容的长度不得少于STDIN_MAX_SZIE, 否则可能导致编码转换错误 */
-        if (fgets_stdin(&data->data, STDIN_MAX_SIZE) == 0) {
-            printReaderError(TooMuchInputError, data->parser, err);
-            *mode = READER_MODE_ERROR;
-            return 0;
-        }
-
-        data->index = 0;
-        data->len = STR_LEN(data->data);
-    }
-
-    if (data->index + len > data->len)  // 超出长度范围
-        len = data->len - data->index;
-    memcpy(dest, data->data + data->index, len);
-    data->index += len;
-    return len;
-}
-
-static void destructStdin(struct readerDataStdin *data) {
-    free(data->data);
-    if (data->sig_int != SIG_ERR)
-        signal(SIGINT, data->sig_int);
-    if (data->sig_term != SIG_ERR)
-        signal(SIGTERM, data->sig_term);
-}
-
-static void initStdinReader(af_Parser *parser, struct readerDataStdin *data) {
-    data->parser = parser;
-}
-
-af_Parser *makeParserByStdin(ConstFilePath file){
-    if (CLEAR_FERROR(stdin))
-        return nullptr;
-
-    DLC_SYMBOL(readerFunc) read_func = MAKE_SYMBOL(readFuncStdin, readerFunc);
-    DLC_SYMBOL(destructReaderFunc) destruct = MAKE_SYMBOL(destructStdin, destructReaderFunc);
-    af_Parser *parser = makeParser(file, read_func, destruct, sizeof(struct readerDataStdin));
-    initStdinReader(parser, (struct readerDataStdin *)parser->reader->data);
-    initParser(parser);
-    FREE_SYMBOL(read_func);
-    FREE_SYMBOL(destruct);
-    return parser;
-}

src/core/reader.cpp

@@ -1,150 +0,0 @@
-#include "core_init.hpp"
-#include "__reader.hpp"
-static void readFirstWord(af_Reader *reader);
-
-af_Reader *makeReader(FileLine line, ConstFilePath file, DLC_SYMBOL(readerFunc) read_func,
-                      DLC_SYMBOL(destructReaderFunc) destruct_func, size_t data_size){
-    auto reader = calloc(1, af_Reader);
-    reader->read_func = COPY_SYMBOL(read_func, readerFunc);
-    reader->destruct = COPY_SYMBOL(destruct_func, destructReaderFunc);
-
-    reader->data = calloc_size(1, data_size);
-    reader->data_size = data_size;
-
-    reader->buf = NEW_STR(DEFAULT_BUF_SIZE);
-    reader->buf_size = DEFAULT_BUF_SIZE;  // buf_size 不包括NUL
-    reader->read = reader->buf;
-
-    reader->line = line;
-    reader->file = strCopy(file);
-    return reader;
-}
-
-af_Reader *initReader(af_Reader *reader) {
-    if (reader->init)
-        return reader;
-    readFirstWord(reader);
-    reader->init = true;
-    return reader;
-}
-
-void freeReader(af_Reader *reader) {
-    if (reader->destruct != nullptr)
-        GET_SYMBOL(reader->destruct)(reader->data);
-    free(reader->data);
-    free(reader->buf);
-    free(reader->file);
-    FREE_SYMBOL(reader->read_func);
-    FREE_SYMBOL(reader->destruct);
-    free(reader);
-}
-
-void *getReaderData(af_Reader *reader) {
-    return reader->data;
-}
-
-char *readWord(size_t del_index, af_Reader *reader) {
-    char *re;
-    int mode = READER_MODE_NORMAL;
-    reader->read = reader->buf;  // 重置指针
-
-    if (del_index == 0)
-        return strCopy(nullptr);  // 返回空字符串
-
-    re = NEW_STR(del_index);
-    memcpy(re, reader->buf, del_index);  // 复制旧字符串
-    memmove(reader->buf, reader->buf + del_index, reader->buf_size - del_index + 1);  // +1是为了涵盖NUL
-
-    if (!reader->read_end) { // 没到尾部, 则写入数据
-        char *write = reader->buf + STR_LEN(reader->buf);  // 数据写入的位置
-        size_t len_ = reader->buf_size - STR_LEN(reader->buf);
-        size_t len = GET_SYMBOL(reader->read_func)(reader->data, write, len_, &mode);
-        if (len > len_)
-            len = len_;
-        *(write + len) = NUL;
-    }
-
-    if (mode == READER_MODE_FINISHED)
-        reader->read_end = true;
-    else if (mode == READER_MODE_ERROR) {
-        reader->read_end = true;
-        reader->read_error = true;
-    }
-
-    /* 计算行号 */
-    for (char *tmp = re; *tmp != NUL; tmp ++) {
-        if (*tmp == '\n')
-            reader->line++;
-    }
-
-    if (!isCharUTF8(re)) {
-        free(re);
-        writeErrorLog(aFunCoreLogger, "Is not utf-8");
-        return nullptr;
-    }
-
-    return re;
-}
-
-static void readFirstWord(af_Reader *reader) {
-    int mode = READER_MODE_NORMAL;
-    reader->read = reader->buf;  // 重置指针
-
-    char *write = reader->buf + STR_LEN(reader->buf);  // 数据写入的位置
-    size_t len_ = reader->buf_size - STR_LEN(reader->buf);
-    size_t len = GET_SYMBOL(reader->read_func)(reader->data, write, len_, &mode);
-    if (len > len_)
-        len = len_;
-    *(write + len) = NUL;
-
-    if (mode == READER_MODE_FINISHED)
-        reader->read_end = true;
-    else if (mode == READER_MODE_ERROR) {
-        reader->read_end = true;
-        reader->read_error = true;
-    }
-}
-
-char getChar(af_Reader *reader) {
-    char ch = *(reader->read);
-    if (ch != NUL) {  // 未读取到末尾
-        reader->read++;
-        return ch;
-    } else if (reader->read_end)  // 读取到末尾, 且无新内容
-        return NUL;
-
-    if (reader->read == reader->buf + reader->buf_size) {
-        char *new_buf = NEW_STR(reader->buf_size + NEW_BUF_SIZE);
-        memcpy(new_buf, reader->buf, reader->buf_size);
-
-        int mode = READER_MODE_NORMAL;
-        size_t len = GET_SYMBOL(reader->read_func)(reader->data, new_buf + reader->buf_size, NEW_BUF_SIZE, &mode);
-        if (len > NEW_BUF_SIZE)
-            len = NEW_BUF_SIZE;
-        *(new_buf + reader->buf_size + len) = NUL;
-
-        if (mode == READER_MODE_FINISHED)
-            reader->read_end = true;
-        else if (mode == READER_MODE_ERROR) {
-            reader->read_end = true;
-            reader->read_error = true;
-        }
-
-        free(reader->buf);
-        reader->buf = new_buf;
-        reader->buf_size = reader->buf_size + NEW_BUF_SIZE;
-        reader->read = reader->buf + reader->buf_size - NEW_BUF_SIZE;  // 当前读取的位置
-    } else {
-        int mode = READER_MODE_NORMAL;
-        size_t len_ = reader->buf_size - (reader->read - reader->buf);  // 总长度  - (已读取长度) = 剩余空白
-        size_t len = GET_SYMBOL(reader->read_func)(reader->data, reader->read, len_, &mode);
-        if (len > len_)
-            len = len_;
-        *(reader->read + len) = NUL;
-    }
-
-    ch = *(reader->read);
-    if (ch != NUL)
-        reader->read++;
-    return ch;
-}

src/core/run.cpp

@@ -1,538 +0,0 @@
-#include "aFunCore.hpp"
-#include "__run.hpp"
-#include "__env.hpp"
-
-/* 工具函数: 初始化类型 */
-static bool iterCodeInit(af_Code *code, int mode, af_Environment *env);
-
-/* 工具函数: Message类函数 */
-static af_Message *getTopMsg(af_Environment *env);
-
-/* 工具函数: 检查类型 */
-static bool checkInMsgType(char *type, af_Environment *env);
-static bool checkLiteral(af_Message **msg, af_Environment *env);
-static int checkMacro(af_Message *msg, af_Environment *env);
-static int checkMsg(af_Message *msg, af_Environment *env);
-bool checkNormalEnd(af_Message *msg, af_Environment *env);
-static bool checkGetArgEnd(af_Message *msg, af_Environment *env);
-static bool checkStop(af_Environment *env);
-
-/* Code 执行函数 */
-static bool codeElement(af_Code *code, af_Environment *env);
-static bool codeBlock(af_Code *code, af_Environment *env);
-static bool runGuardian(af_Environment *env);
-
-/*
- * 函数名: checkInMsgType
- * 目标: 检查type是否在对应的msg_type中 (检查该activity是否可以处理该信息)
- */
-static bool checkInMsgType(char *type, af_Environment *env) {
-    if (env->activity->body_next == nullptr || env->activity->body_next->msg_type == nullptr)
-        return false;
-    for (char *msg_type_node = *env->activity->body_next->msg_type; msg_type_node != nullptr; msg_type_node++) {
-        if (EQ_STR(type, msg_type_node))
-            return true;
-    }
-    return false;
-}
-
-/*
- * 函数名: checkLiteral
- * 目标: 检查是否字面量调用, 若是则返回true并调用API, 否则返回false不做修改
- */
-static bool checkLiteral(af_Message **msg, af_Environment *env) {
-    if (!env->activity->is_literal)  // 非字面量
-        return true;
-    if ((*msg) == nullptr || !EQ_STR((*msg)->type, "NORMAL"))  // (*msg)非正常值
-        return false;
-
-    af_Object *obj = *(af_Object **)((*msg)->msg);
-    auto func = (obj_literalSetting *)findAPI("obj_literalSetting", getObjectAPI(obj));
-    if (func == nullptr) {
-        gc_delObjectReference(obj, env);
-        freeMessage(*msg);
-        *msg = makeERRORMessage(TYPE_ERROR, API_NOT_FOUND_INFO(obj_literalSetting), env);
-        return false;
-    }
-
-    for (af_LiteralDataList *ld = env->activity->ld; ld != nullptr; ld = ld->next)
-        func(getObjectID(obj), obj, getObjectData(obj), ld->literal_data, env);
-
-    freeAllLiteralData(env->activity->ld);
-    env->activity->ld = nullptr;
-    env->activity->is_literal = false;
-    writeTrackLog(aFunCoreLogger, "Literal %p", obj);
-    return true;
-}
-
-/*
- * 函数名: checkMacro
- * 目标: 检查是否宏函数调用, 若是则返回true并修改activity隐式调用(activity继续执行时则会执行该调用), 否则返回false不做修改
- * 返回值:
- * -1 非宏函数
- *  0 错误
- *  1 宏函数
- */
-static int checkMacro(af_Message *msg, af_Environment *env) {
-    if (env->activity->fi == nullptr || !env->activity->fi->is_macro)  // 非宏函数
-        return -1;
-    if (!EQ_STR(msg->type, "NORMAL"))  // msg非正常值
-        return -1;
-
-    af_Object *obj = *(af_Object **)(msg->msg);
-    bool re = pushMacroFuncActivity(obj, env);
-    gc_delObjectReference(obj, env);
-    freeMessage(msg);
-    if (re)
-        return 1;
-    return 0;
-}
-
-/*
- * 函数名: iterCodeInit
- * 目标: 初始化activity和environment (若environment中未存在activity则通过code新增一个TopActivity, 否则沿用原activity)
- *
- * mode 标识运行模式
- * 0. 在top运行
- * 1. 在import运行
- * 2. 直接运行
- * 3. gc模式
- */
-static bool iterCodeInit(af_Code *code, int mode, af_Environment *env) {
-    if (env == nullptr || pthread_mutex_trylock(&env->in_run) != 0)
-        return false;
-    if (env->activity == nullptr) {
-        pthread_mutex_unlock(&env->in_run);
-        return false;
-    }
-
-    switch (mode) {
-        case 0:
-            if (env->activity->type != act_top || !codeSemanticCheck(code))
-                return false;
-            setActivityBtTop(nullptr, env->activity);  // 直接就在NORMAL期, bt_top不被设定
-            setActivityBtStart(code, env->activity);
-            break;
-        case 1: {
-            if (env->activity->type != act_top)
-                return false;
-            env->activity->file = strCopy("top.aun.sys");
-
-            char *name = getFileName(code->path);
-            pushImportActivity(code, nullptr, name, env);
-            free(name);
-            break;
-        }
-        case 2:
-            if (env->activity->prev == nullptr || env->activity->prev->type != act_top)
-                return false;
-            env->activity->file = strCopy("top-gc.aun.sys");
-
-            if (env->activity->type == act_guardian || !codeSemanticCheck(env->activity->bt_start) || env->activity->bt_next == nullptr || code != nullptr)
-                return false;
-            break;
-        case 3:
-            pthread_mutex_lock(&env->status_lock);
-            env->status = core_normal_gc;
-            pthread_mutex_unlock(&env->status_lock);
-
-            if (env->activity->type != act_guardian || code != nullptr)
-                return false;
-            break;
-        default:
-            return false;
-    }
-
-    return true;
-}
-
-/*
- * 函数名: codeElement
- * 目标: 执行变量访问或字面量生成 (设置bt_next)
- * (1) 执行字面量生成代码 (设置bt_next)
- *     返回-false 表示执行错误 (msg_down中写入消息)
- *     返回-true  表示执行成功 (msg_down中无消息写入, 函数仅设置activity无实质性代码执行)
- * (2) 执行变量访问代码:
- *     返回-false 表示执行失败, 或执行成功得到一个变量值      (msg_down中写入消息)
- *     返回-true  表示执行成功, 得到一个对象函数, 并且隐式调用 (msg_down中无消息写入, 函数仅设置activity无实质性代码执行)
- */
-static bool codeElement(af_Code *code, af_Environment *env) {
-    bool in_protect;
-    char *func;
-    af_Var *var;
-
-    if (checkLiteralCode(code->element.data, &func, &in_protect, env)) {
-        /* 字面量执行 */
-        if (in_protect)
-            var = findVarFromVarSpace(func, env->activity->belong, env->protect);
-        else
-            var = findVarFromVarList(func, env->activity->belong, env->activity->run_varlist);
-
-        if (var == nullptr) {
-            pushMessageDown(makeERRORMessageFormat(LITERAL_ERROR, env, "Literal not found: %s: %s.", code->element.data, func), env);
-            return false;
-        }
-
-        af_Object *obj = findVarNode(var, nullptr, env);
-        writeTrackLog(aFunCoreLogger, "Get literal %s : %p", code->element.data, obj);
-        bool res = pushLiteralActivity(code, code->element.data, obj, env);
-        gc_delObjectReference(obj, env);
-        return res;
-    }
-
-    /* 变量执行 */
-    var = findVarFromVarList(code->element.data, env->activity->belong, env->activity->run_varlist);
-
-    if (var == nullptr) {
-        pushMessageDown(makeERRORMessageFormat(VARIABLE_ERROR, env, "Variable not found: %s.", code->element.data), env);
-        return false;
-    }
-
-    af_Object *obj = findVarNode(var, nullptr, env);
-    obj_isObjFunc *is_obj;
-    obj_isInfixFunc *is_infix;
-
-    if (code->prefix != getPrefix(E_QUOTE, env)) {
-        af_ObjectAPI *api = getObjectAPI(obj);
-        const std::string &id = getObjectID(obj);
-        if ((is_obj = (obj_isObjFunc *)findAPI("obj_isObjFunc", api)) != nullptr && is_obj(id, obj)) {
-            bool res = pushVariableActivity(code, obj, env);  // 对象函数
-            gc_delObjectReference(obj, env);
-            return res;
-        } else if (env->activity->status != act_func_get && // 在act_func_get 模式下不检查是否为is_infix函数 因为本来就要将其作为函数调用
-                 (is_infix = (obj_isInfixFunc *)findAPI("obj_isInfixFunc", api)) != nullptr && is_infix(id, obj)) {
-            pushMessageDown(makeERRORMessageFormat(INFIX_PROTECT, env,
-                                                   "Infix protect variable: %s.", code->element.data), env);
-            gc_delObjectReference(obj, env);
-            return false;
-        }
-    }
-
-    pushMessageDown(makeNORMALMessage(obj, env), env);
-    setActivityBtNext(env->activity->bt_next->next, env->activity);
-    writeTrackLog(aFunCoreLogger, "Get variable %s : %p", code->element.data, obj);
-    return false;
-}
-
-/*
- * 函数名: codeBlock
- * 目标: 执行括号语法 (顺序执行, 函数调用)
- * 返回-false 表示执行错误 (msg_down中写入消息)
- * 返回-true  表示执行成功 (msg_down中无消息写入, 函数仅设置activity无实质性代码执行)
- */
-static bool codeBlock(af_Code *code, af_Environment *env) {
-    if (code->prefix == getPrefix(B_EXEC, env) && code->block.type == parentheses)  // 顺序执行, 返回尾项
-        return pushExecutionActivity(code, false, env);
-    else if (code->prefix == getPrefix(B_EXEC_FIRST, env) && code->block.type == brackets)  // 顺序执行, 返回首项
-        return pushExecutionActivity(code, true, env);
-    else
-        return pushFuncActivity(env->activity->bt_next, env);
-}
-
-static bool runGuardian(af_Environment *env) {
-    af_GuardianList *gl = nullptr;
-    af_GuardianList **pgl = ≷
-    for (af_Guardian *gd = env->guardian; gd != nullptr; gd = gd->next) {
-        if (gd->always || !env->activity->is_guard) { // guardian被标记为一直执行, 或者非is_guard模式
-            af_GuardianList *new_gl = GET_SYMBOL(gd->func)(gd->type, env->activity->is_guard, gd->data, env);
-            if (new_gl != nullptr)
-                pgl = contectGuardianList(new_gl, pgl);
-        }
-    }
-
-    if (gl != nullptr) {
-        env->activity->process_msg_first++;  //  guardian开始处理时, 已经在原activity中有msg了, 所以要先处理
-        pushGuardianActivity(gl, pgl, env);
-        return true;
-    }
-
-    return false;
-}
-
-/*
- * 函数名: getTopMsg
- * 目标: 获取msg_down顶层信息, 若没有则产生错误
- */
-static af_Message *getTopMsg(af_Environment *env) {
-    if (env->activity->msg_down == nullptr)  // 若未获得 msg
-        return makeERRORMessage(RUN_ERROR, NOT_MSG_INFO, env);
-    else
-        return getFirstMessage(env);
-}
-
-/*
- * 函数名: checkMsg
- * 目标: 检查msg是否为NORMAL, 并且检查该信号是否可被处理
- * 返回- (1) 正常
- * 返回- (0) 不可处理的信号
- * 返回-(-1) 非正常但通过msg_type判断为可被处理的信号
- */
-static int checkMsg(af_Message *msg, af_Environment *env) {
-    if (EQ_STR(msg->type, "NORMAL"))
-        return 1;  // 正常
-
-    pushMessageDown(msg, env);  // msg不弹出
-    if (env->activity->status != act_func_normal || !checkInMsgType(msg->type, env)) {  // 非normal模式, 或normal模式下msg_type不匹配该msg
-        env->activity->return_first = false;
-        pthread_mutex_lock(env->activity->gc_lock);
-        env->activity->return_obj = nullptr;
-        pthread_mutex_unlock(env->activity->gc_lock);
-        return 0;
-    }
-
-    return -1;  // 遇到非normal, 但继续运行
-}
-
-/*
- * 函数名: checkNormalEnd
- * 目标: 检查act_normal是否运行到结尾 (若运行到结尾则返回true, 否则返回false)
- */
-bool checkNormalEnd(af_Message *msg, af_Environment *env) {
-    if (env->activity->bt_next == nullptr) {
-        if (env->activity->type == act_top || env->activity->type == act_top_import) {
-            pushMessageDown(msg, env);
-            return true;
-        } else if (setFuncActivityToNormal(env) == 0) {  // 已经没有下一步了
-            if (msg == nullptr) {  // msg 得不到处理
-                pushMessageDown(makeERRORMessage(RUN_ERROR, NOT_NORMAL_MSG_INFO, env), env);
-                return true;
-            }
-
-            switch (checkMacro(msg, env)) {
-                case 0:
-                    return true;  // 错误
-                case 1:
-                    return false;  // 宏函数
-                case -1:
-                default:
-                    break;  // 非宏函数
-            }
-
-            checkLiteral(&msg, env);  // 检查是否字面量
-            pushMessageDown(msg, env);
-            return true;
-        } else if (msg != nullptr) {
-            gc_delObjectReference(*(af_Object **) (msg->msg), env);  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
-            freeMessage(msg);
-        }
-    } else if (msg != nullptr) {
-        if (env->activity->bt_next->type == code_block && env->activity->bt_next->block.type == parentheses &&
-            env->activity->bt_next->prefix != getPrefix(B_EXEC, env)) {
-            pthread_mutex_lock(env->activity->gc_lock);
-            env->activity->parentheses_call = *(af_Object **) (msg->msg);  // 类前缀调用
-            pthread_mutex_unlock(env->activity->gc_lock);
-        }
-        gc_delObjectReference(*(af_Object **)(msg->msg), env);  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
-        freeMessage(msg);
-    }
-    return false;
-}
-
-/*
- * 函数名: checkGetArgEnd
- * 目标: 检查act_arg是否运行到结尾 (若运行到结尾则返回true, 否则返回false)
- */
-static bool checkGetArgEnd(af_Message *msg, af_Environment *env) {
-    env->activity->acl_done->result = *(af_Object **)(msg->msg);  // 保持 gc 引用计数
-    freeMessage(msg);
-    if (env->activity->acl_done->next == nullptr) { // 参数设定结束
-        setArgCodeListToActivity(nullptr, env);
-        return true;
-    }
-    env->activity->acl_done = env->activity->acl_done->next;
-    setArgCodeListToActivity(env->activity->acl_done, env);
-    return false;
-}
-
-static bool checkStop(af_Environment *env) {
-    enum af_CoreStatus status = getCoreStatus(env);
-    if (status == core_stop || status == core_exit) {
-        while (env->activity->type != act_top || env->activity->prev != nullptr)
-            popActivity(false, nullptr, env);  // is_normal=false, 非正常退出, 释放mark
-        popActivity(false, nullptr, env);  // 再释放 act_top
-        return true;
-    }
-    return false;
-}
-
-/*
- * 函数名: iterCode
- * 目标: 运行代码 (代码可通过code参数传入, 或通过env->activity传入)
- * 注意: 曾为缩短改函数而将该函数的内容进行大量的封装
- *      但实际上, 这个函数各个部分的关联性是很强的
- *      因此, 取消了封装, 反而提高了代码的可读性
- *
- *      因为该函数的大部分内容运行在循环中, 因此使用continue表示不在运行后面的代码
- */
-bool iterCode(af_Code *code, int mode, af_Environment *env){
-    if (!iterCodeInit(code, mode, env))
-        return false;
-    bool re = true;
-    makeMonitor(env);  // 启动监视线程
-    /*
-     * 问题: 如何确保循环跳出之前, top-Activity已经被pop。(即执行释放)
-     * 为什么会有这个问题: top-Activity只有在bt_next=nullptr时被pop, 而循环也是在bt_next=nullptr时可能被退出
-     *                  如此以来就可能导致在pop之前循环就退出了
-     * 实际上并不会发生。
-     * bt_next设定后，会出现两种情况: 一是马上检查bt_next, 而是设定了pass
-     * 设定了pass是意味着压入新的activity。当新的activity被返回时, 必定设置了process_msg_first
-     * 而process_msg_first时, 也会检查bt_next
-     *
-     * 【run-code设置了bt_next】 -> 检查bt_next并可能做pop处理 -> while循环检查bt_next  [例如变量访问语句]
-     * 【run-code设置了bt_next】 -> 压入了新的activity -> while循环检查 和一系列运行
-     *  -> 新activity返回, 设定process_msg_first -> while循环检查 (因为process_msg_first, 所以不会跳出循环)
-     *  -> process_msg_first会处理msg, 检查bt_next.
-     *
-     * popActivity会是一定会设置process_msg_first, 除了gc机制。
-     * 而gc机制前后, bt_next不会改变，这意味着如果gc之后while循环就会被跳出, 那么gc之前while循环早就跳出了
-     */
-
-    /* 必须位于act_top, 且无next, 并且无msg处理才退出执行 */
-    while (env->activity->type != act_top || env->activity->bt_next != nullptr || env->activity->process_msg_first != 0) {
-        /* 检查是否需要退出执行 */
-        if (checkStop(env)) {
-            re = false;
-            goto RETURN;
-        }
-
-        if (env->activity->type == act_guardian) {
-            if (env->activity->gl_next == nullptr) {
-                popActivity(true, nullptr, env);  // 结束运行
-                if (mode == 3)  // mode = 3, 表示只运行守护器
-                    break;
-            } else
-                pushGuadianFuncActivity(env->activity->gl_next, env);
-            continue;
-        }
-
-        /* 切换执行的 var_list */
-        pthread_mutex_lock(env->activity->gc_lock);
-        if (env->activity->type == act_func && env->activity->status == act_func_arg) {
-            if (env->activity->run_in_func && env->activity->func_varlist != nullptr)
-                env->activity->run_varlist = env->activity->func_varlist;
-            else
-                env->activity->run_varlist = env->activity->out_varlist;
-            env->activity->count_run_varlist = 0;
-        } else if (env->activity->type == act_func && env->activity->status == act_func_get) {
-            env->activity->run_varlist = env->activity->out_varlist;
-            env->activity->count_run_varlist = 0;
-        }
-        pthread_mutex_unlock(env->activity->gc_lock);
-
-        /* 无代码运行 */
-        if (env->activity->bt_next == nullptr && env->activity->process_msg_first == 0) {  // 无代码运行, 并且非msg_first
-            switch (env->activity->status) {
-                case act_func_get:
-                case act_func_normal:
-                    popActivity(false, makeERRORMessage(RUN_ERROR, NOT_CODE_INFO, env), env);
-                    break;
-                case act_func_arg:  // 无参数设定
-                    if (!setFuncActivityAddVar(env))
-                        popActivity(false, nullptr, env);
-                    break;
-                default:
-                    break;
-            }
-            continue;  // 后面的代码不再运行
-        }
-
-        /* 有代码运行 */
-        bool pass_msg = false;  // 表示不处理msg
-        if (env->activity->process_msg_first == 0) {  /* 运行实际代码 */
-            env->activity->bt_done = env->activity->bt_next;
-            switch (env->activity->bt_done->type) {
-                case code_element:
-                    if (codeElement(env->activity->bt_done, env))
-                        pass_msg = true;
-                    break;
-                case code_block:
-                    if (codeBlock(env->activity->bt_done, env))
-                        pass_msg = true;  // 若运行成功则跳转到下一次运行, 该步骤仅为设置Activity
-                    break;
-                default:
-                    break;
-            }
-        } else
-            env->activity->process_msg_first--;
-
-        if (pass_msg)
-            continue;  // 后面的代码不再运行
-
-        /* 执行守护器 */
-        if (runGuardian(env))
-            continue;  // 需要执行守护器
-
-        /* 处理msg */
-        af_Message *msg = getTopMsg(env);
-        switch (checkMsg(msg, env)) {
-            case 0:  // 不可处理的信号
-                popActivity(false, nullptr, env);  // 跳出当前activity
-                continue;  // 下面的代码不再执行
-            case 1:  // 正常信号
-                if (env->activity->return_first && env->activity->return_obj == nullptr) { // 设置return_first
-                    pthread_mutex_lock(env->activity->gc_lock);
-                    env->activity->return_obj = *(af_Object **) msg->msg;
-                    pthread_mutex_unlock(env->activity->gc_lock);
-                }
-                break;
-            case -1:  // NORMAL模式下, 非正常但可处理 [已经放回]
-            default:
-                assertErrorLog(env->activity->status == act_func_normal, aFunCoreLogger, "");
-                break;
-        }
-
-        switch (env->activity->status) {
-            case act_func_normal:  // 需要考虑 msg == nullptr
-                if (checkNormalEnd(msg, env))
-                    popActivity(true, nullptr, env);  // 正常退出
-                break;
-            case act_func_get: {
-                af_Object *func = *(af_Object **) (msg->msg);  // func仍保留了msg的gc计数
-                if (!setFuncActivityToArg(func, env))
-                    popActivity(false, nullptr, env);
-                gc_delObjectReference(func, env);  // 释放计数 (setFuncActivityToArg 不需要计数)
-                freeMessage(msg);
-                break;
-            }
-            case act_func_arg: {
-                if (checkGetArgEnd(msg, env)) {  // 参数设定完成
-                    if (!setFuncActivityAddVar(env))
-                        popActivity(false, nullptr, env);
-                }
-                break;
-            }
-            default:
-                break;
-        }
-    }
-
-RETURN:
-    pthread_mutex_unlock(&env->in_run);
-    freeMonitor(env);
-    return re;
-}
-
-/*
- * 函数名: iterDestruct
- * 目标: 对所有ObjectData执行析构函数
- * 会循环不断检测是否有新增ObjectData并且需要析构
- * deep - 表示最大迭代深度 (设置为0表示不限制)
- */
-bool iterDestruct(int deep, af_Environment *env) {
-    for (int count = 0; deep == 0 || deep > count; count++) {
-        af_GuardianList *gl = nullptr;
-        paf_GuardianList pdl = ≷
-
-        pdl = checkAllDestruct(env, pdl);
-        if (gl == nullptr)
-            return true;
-        pushGuardianActivity(gl, pdl, env);
-        if (!iterCode(nullptr, 3, env))
-            return false;
-    }
-
-    pthread_mutex_lock(&env->status_lock);
-    env->status = core_exit;
-    pthread_mutex_unlock(&env->status_lock);
-    return false;
-}

src/core/sig.cpp

@@ -1,181 +0,0 @@
-#include "aFunCore.hpp"
-#include "__sig.hpp"
-#include "pthread.h"
-
-typedef void (*HandleFunc) (int);
-struct af_SignalInfo {
-    HandleFunc sig_int;
-    HandleFunc sig_term;
-
-    volatile sig_atomic_t flat_int;  // SIGUSR1 (*nix)
-    volatile sig_atomic_t flat_term;  // SIGUSR1 (*nix)
-
-#ifndef aFunWIN32_NO_CYGWIN
-    volatile sig_atomic_t flat_u1;  // SIGUSR1 (*nix)
-    volatile sig_atomic_t flat_u2;  // SIGUSR1 (*nix)
-
-    HandleFunc sig_u1;
-    HandleFunc sig_u2;
-    sigset_t new_sigset;
-    sigset_t old_sigset;
-#endif
-};
-
-static void aFuncheckSignal();
-typedef struct af_SignalInfo af_SignalInfo;
-af_SignalInfo sig_info;
-bool init_sig_info = false;
-pthread_mutex_t sig_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-
-#ifndef aFunWIN32_NO_CYGWIN
-static void aFunSigFunc(int signum);
-static void aFunSigFunc(int signum) {
-    switch (signum) {
-        case SIGINT:
-            sig_info.flat_int = 1;
-            break;
-        case SIGTERM:
-            sig_info.flat_term = 1;
-            break;
-        case SIGUSR1:
-            sig_info.flat_u1 = 1;
-            break;
-        case SIGUSR2:
-            sig_info.flat_u2 = 1;
-            break;
-        default:
-            break;
-    }
-}
-#endif
-
-void aFunSignalInit() {
-    pthread_mutex_lock(&sig_mutex);
-    if (init_sig_info) {
-        pthread_mutex_unlock(&sig_mutex);
-        writeWarningLog(aFunCoreLogger, "Double signal init");
-        return;
-    }
-
-    writeDebugLog(aFunCoreLogger, "Signal init");
-    init_sig_info = true;
-#ifdef aFunWIN32_NO_CYGWIN
-    sig_info.sig_int = signal(SIGINT, SIG_IGN);
-    sig_info.sig_term = signal(SIGTERM, SIG_IGN);
-    stdio_signal_init(true);
-#else
-    sigemptyset(&sig_info.old_sigset);
-    sigemptyset(&sig_info.new_sigset);
-    sigaddset(&sig_info.new_sigset, SIGINT);
-    sigaddset(&sig_info.new_sigset, SIGTERM);
-    sigaddset(&sig_info.new_sigset, SIGUSR1);
-    sigaddset(&sig_info.new_sigset, SIGUSR2);
-    sigprocmask(SIG_BLOCK, &sig_info.new_sigset, &sig_info.old_sigset);
-
-    sig_info.sig_int = signal(SIGINT, aFunSigFunc);
-    sig_info.sig_term = signal(SIGTERM, aFunSigFunc);
-    sig_info.sig_u1 = signal(SIGUSR1, aFunSigFunc);
-    sig_info.sig_u2 = signal(SIGUSR2, aFunSigFunc);
-
-    sig_info.flat_int = 0;
-    sig_info.flat_term = 0;
-    sig_info.flat_u1 = 0;
-    sig_info.flat_u2 = 0;
-#endif
-    pthread_mutex_unlock(&sig_mutex);
-}
-
-void aFunSignalRecover() {
-    pthread_mutex_lock(&sig_mutex);
-    if (!init_sig_info) {
-        pthread_mutex_unlock(&sig_mutex);
-        writeWarningLog(aFunCoreLogger, "Signal recover before init");
-        return;
-    }
-
-    HandleFunc re;
-    writeDebugLog(aFunCoreLogger, "Signal recover");
-
-    if (sig_info.sig_int != SIG_ERR) {
-        re = signal(SIGINT, sig_info.sig_int);
-        assertWarningLog(re != SIG_ERR, aFunCoreLogger, "SIGINT recover fail");
-    }
-
-    if (sig_info.sig_term != SIG_ERR) {
-        re = signal(SIGTERM, sig_info.sig_term);
-        assertWarningLog(re != SIG_ERR, aFunCoreLogger, "SIGTERM recover fail");
-    }
-
-#ifdef aFunWIN32_NO_CYGWIN
-    stdio_signal_init(false);
-#else
-    if (sig_info.sig_u1 != SIG_ERR) {
-        re = signal(SIGUSR1, sig_info.sig_u1);
-        assertWarningLog(re != SIG_ERR, aFunCoreLogger, "SIGUSR1 recover fail");
-    }
-
-    if (sig_info.sig_u2 != SIG_ERR) {
-        re = signal(SIGUSR2, sig_info.sig_u2);
-        assertWarningLog(re != SIG_ERR, aFunCoreLogger, "SIGUSR2 recover fail");
-    }
-    sigprocmask(SIG_SETMASK, &sig_info.old_sigset, nullptr);
-#endif
-    pthread_mutex_unlock(&sig_mutex);
-}
-
-static void aFuncheckSignal() {
-    /* 该函数是内部函数, 不负责加锁 */
-#ifdef aFunWIN32_NO_CYGWIN
-    if (stdio_check_signal())
-        sig_info.flat_int = 1;
-#else
-    for (int i = 0; i < 4; i++) {
-        // 标准: sigprocmask 执行返回前必有一个未递达(如果有)的信号递达
-        // 循环 count 次, 确保信号都递达
-        signal(SIGINT, aFunSigFunc);
-        signal(SIGTERM, aFunSigFunc);
-        signal(SIGUSR1, aFunSigFunc);
-        signal(SIGUSR2, aFunSigFunc);
-        sigprocmask(SIG_SETMASK, &sig_info.old_sigset, nullptr);  // 让信号递达
-    }
-    sigprocmask(SIG_BLOCK, &sig_info.new_sigset, &sig_info.old_sigset);
-#endif
-}
-
-bool aFunGetSignal(int signum) {
-    pthread_mutex_lock(&sig_mutex);
-    if (!init_sig_info) {
-        pthread_mutex_unlock(&sig_mutex);
-        return false;
-    }
-
-    bool re = false;
-    aFuncheckSignal();
-
-    switch (signum) {
-        case SIGINT:
-            re = sig_info.flat_int == 1;
-            sig_info.flat_int = 0;
-            break;
-        case SIGTERM:
-            re = sig_info.flat_term == 1;
-            sig_info.flat_term = 0;
-            break;
-#ifndef aFunWIN32_NO_CYGWIN
-        case SIGUSR1:
-            re = sig_info.flat_u1 == 1;
-            sig_info.flat_u1 = 0;
-            break;
-        case SIGUSR2:
-            re = sig_info.flat_u2 == 1;
-            sig_info.flat_u1 = 0;
-            break;
-#endif
-        default:
-            break;
-    }
-
-    pthread_mutex_unlock(&sig_mutex);
-    return re;
-}

src/core/syntactic.cpp

@@ -1,234 +0,0 @@
-#include <cctype>
-#include "aFunCore.hpp"
-#include "__code.hpp"
-#include "__parser.hpp"
-#include "parserl_warning_error.h"
-
-#define printSyntacticError(info, parser) do { \
-    writeErrorLog(aFunCoreLogger, "[Syntactic] %s:%d %s", (parser)->reader->file, (parser)->reader->line, (info ## Log)); \
-    printf_stderr(0, "[%s] %s:%d : %s\n", HT_aFunGetText(syntactic_n, "Syntactic"), (parser)->reader->file,               \
-                  (parser)->reader->line, info ## Console); \
-    (parser)->is_error = true; \
-} while(0)
-
-static bool getToken(af_Parser *parser) {
-    if (parser->syntactic->back) {
-        parser->syntactic->back = false;
-        return true;
-    }
-
-    parser->syntactic->token = getTokenFromLexical(&parser->syntactic->text, parser);
-    return parser->syntactic->token != TK_ERROR;  // 非错误则返回true, 遇到错误则返回false
-}
-
-static bool goBackToken(af_Parser *parser) {
-    if (parser->syntactic->back)
-        return false;  // 已经有一个回退
-    parser->syntactic->back = true;
-    return true;
-}
-
-static af_Code *codeList(size_t deep, af_Parser *parser);
-
-static af_Code *code(size_t deep, char prefix, af_Parser *parser) {  // NOLINT
-    af_Code *re;
-    af_Code *code_list = nullptr;
-    deep++;
-
-    getToken(parser);
-    switch (parser->syntactic->token) {
-        case TK_ELEMENT_SHORT:
-        case TK_ELEMENT_LONG:
-            re = makeElementCode(parser->syntactic->text, prefix, parser->reader->line, nullptr);
-            if (re == nullptr) {
-                writeErrorLog(aFunCoreLogger, "Creat element code error: %s", parser->syntactic->text);
-                freeAllCode(code_list);
-                return nullptr;
-            }
-            free(parser->syntactic->text);
-            break;
-        case TK_LP:
-            if (deep <= SYNTACTIC_MAX_DEEP)
-                code_list = codeList(deep, parser);
-            else
-                printSyntacticError(TooDeep, parser);
-
-            getToken(parser);
-            switch (parser->syntactic->token) {
-                case TK_RP:
-                    break;
-                case TK_ERROR:
-                    freeAllCode(code_list);
-                    return nullptr;
-                default:
-                    goBackToken(parser);
-                    printSyntacticError(CodeBlockEndError, parser);
-                    break;
-            }
-
-            re = makeBlockCode(parentheses, code_list, prefix, parser->reader->line, nullptr, nullptr);
-            break;
-        case TK_LB:
-            if (deep <= SYNTACTIC_MAX_DEEP)
-                code_list = codeList(deep, parser);
-            else
-                printSyntacticError(TooDeep, parser);
-
-            getToken(parser);
-            switch (parser->syntactic->token) {
-                case TK_RB:
-                    break;
-                case TK_ERROR:
-                    freeAllCode(code_list);
-                    return nullptr;
-                default:
-                    goBackToken(parser);
-                    printSyntacticError(CodeBlockEndError, parser);
-                    break;
-            }
-
-            re = makeBlockCode(brackets, code_list, prefix, parser->reader->line, nullptr, nullptr);
-            break;
-        case TK_LC:
-            if (deep <= SYNTACTIC_MAX_DEEP)
-                code_list = codeList(deep, parser);
-            else
-                printSyntacticError(TooDeep, parser);
-
-            getToken(parser);
-            switch (parser->syntactic->token) {
-                case TK_RC:
-                    break;
-                case TK_ERROR:
-                    freeAllCode(code_list);
-                    return nullptr;
-                default:
-                    goBackToken(parser);
-                    printSyntacticError(CodeBlockEndError, parser);
-                    break;
-            }
-
-            re = makeBlockCode(curly, code_list, prefix, parser->reader->line, nullptr, nullptr);
-            break;
-        case TK_ERROR:
-            return nullptr;
-        default:
-            printSyntacticError(CodeBlockEndError, parser);
-            return nullptr;
-    }
-
-    if (re == nullptr)
-        printSyntacticError(MakeCodeFail, parser);
-    return re;
-}
-
-static af_Code *codePrefix(size_t deep, af_Parser *parser) {  // NOLINT
-    char ch = NUL;
-    getToken(parser);
-    if (parser->syntactic->token != TK_PREFIX) {
-        goBackToken(parser);
-        printSyntacticError(PrefixError, parser);
-    } else if (STR_LEN( parser->syntactic->text) != 1) {
-        printSyntacticError(PrefixError, parser);
-        free(parser->syntactic->text);
-    } else {
-        ch = *(parser->syntactic->text);
-        free(parser->syntactic->text);
-    }
-
-    return code(deep, ch, parser);
-}
-
-static af_Code *codeList(size_t deep, af_Parser *parser) {  // NOLINT
-    af_Code *re = nullptr;
-    af_Code **pre = &re;
-    af_Code *code_list;
-
-    while (true) {
-        getToken(parser);
-        switch (parser->syntactic->token) {
-            case TK_PREFIX:
-                goBackToken(parser);
-                code_list = codePrefix(deep, parser);
-                if (code_list != nullptr)
-                    pre = &(pushCode(pre, code_list)->next);
-                break;
-
-            case TK_ELEMENT_SHORT:
-            case TK_ELEMENT_LONG:
-            case TK_LP:
-            case TK_LB:
-            case TK_LC:
-                goBackToken(parser);
-                code_list = code(deep, NUL, parser);
-                if (code_list != nullptr)
-                    pre = &(pushCode(pre, code_list)->next);
-                break;
-            case TK_ERROR:
-                freeAllCode(re);
-                return nullptr;
-            default: /* 结束 */
-                goBackToken(parser);
-                return re;
-        }
-    }
-}
-
-static af_Code *codeListEnd(af_Parser *parser) {
-    af_Code *re = nullptr;
-    af_Code **pre = &re;
-    af_Code *code_list;
-
-    getToken(parser);
-    switch (parser->syntactic->token) {
-        case TK_EOF:
-            break;  // 结束
-        case TK_PREFIX:
-        case TK_ELEMENT_SHORT:
-        case TK_ELEMENT_LONG:
-        case TK_LP:
-        case TK_LB:
-        case TK_LC:
-            goBackToken(parser);
-            code_list = codeList(0, parser);
-            pushCode(pre, code_list);
-
-            getToken(parser);
-            switch (parser->syntactic->token) {
-                case TK_EOF:
-                    break;  // 正常结束
-                case TK_ERROR:
-                    freeAllCode(re);
-                    return nullptr;
-                default:
-                    printSyntacticError(CodeListEndError, parser);
-                    freeAllCode(re);
-                    return nullptr;
-            }
-            break;
-        case TK_ERROR:
-            return nullptr;
-        default:
-            printSyntacticError(CodeListStartError, parser);
-            return nullptr;
-    }
-
-    return re;
-}
-
-af_Code *parserCode(af_Parser *parser){
-    af_Code *code = codeListEnd(parser);
-    if (parser->is_error || parser->reader->read_error || parser->lexical->is_error) {
-        freeAllCode(code);
-        return nullptr;
-    }
-
-    if (code != nullptr) {
-        if (parser->reader->file != nullptr)
-            code->path = strCopy(parser->reader->file);
-        else
-            code->path = strCopy("unknown.aun");
-    }
-
-    return code;
-}

src/core/thread.cpp

@@ -1,74 +0,0 @@
-#include "__env.hpp"
-#include "__run.hpp"
-#include "core_init.hpp"
-#include "thread.hpp"
-
-struct EnvCode {
-    af_Environment *env;
-    af_Code *code;
-    bool not_copy_code;
-};
-
-static void *runThread(void *ec);
-
-/**
- * 启动一个次线程运行代码
- * 注意: vs需要 gc_addReference
- * @param env 父线程env
- * @param vs 压入的变量空间
- * @param code 执行的代码
- */
-af_Environment *startRunThread(af_Environment *env, af_VarSpace *vs, af_Code *code, bool not_copy_code, bool derive_tmp,
-                               bool derive_guardian, bool derive_lr, bool enable){
-    auto base = env->base;
-    auto new_env = deriveEnvironment(derive_tmp, derive_guardian, derive_lr, enable, base);
-
-    if (vs == nullptr) {
-        af_Object *obj = getGlobal(env);
-        vs = makeVarSpace(obj, 3, 3, 3, env);
-        gc_delObjectReference(obj, env);
-    }
-
-    new_env->activity->run_varlist = pushVarList(vs, new_env->activity->run_varlist);
-    new_env->activity->count_run_varlist++;
-    gc_delVarSpaceReference(vs, base);
-
-    if (enable)  // 如果未Enable, 则暂时不启动线程
-        startRunThread_(new_env, code, not_copy_code);
-    return new_env;
-}
-
-
-void startRunThread_(af_Environment *env, af_Code *code, bool not_copy_code){
-    auto ec = calloc(1, struct EnvCode);
-    ec->env = env;
-    ec->code = code;
-    ec->not_copy_code = not_copy_code;
-
-    pthread_t id;
-    pthread_create(&id, nullptr, runThread, ec);
-    pthread_detach(id);
-}
-
-
-static void *runThread(void *ec) {
-    af_Environment *env = ((struct EnvCode *)ec)->env;
-    af_Code *code = ((struct EnvCode *)ec)->code;
-    bool not_copy_code = ((struct EnvCode *)ec)->not_copy_code;
-    free(ec);
-
-    if (!not_copy_code)  // “非-不要复制代码” 即 “要复制代码”
-        code = copyCode(code);
-
-    writeInfoLog(aFunCoreLogger, "Thread start");
-    iterCode(code, 0, env);
-
-    writeInfoLog(aFunCoreLogger, "Thread free-code");
-    freeAllCode(code);
-
-    writeInfoLog(aFunCoreLogger, "Thread free-env");
-    freeEnvironment(env);
-
-    writeInfoLog(aFunCoreLogger, "Thread end");
-    return nullptr;
-}

src/core/var.cpp

@@ -1,744 +0,0 @@
-#include "__var.hpp"
-#include "core_init.hpp"
-#include "tool.hpp"
-
-
-/* VarNode 创建与释放 */
-static af_VarNode *makeVarNode(af_Object *obj, const char *id);
-static af_VarNode *freeVarNode(af_VarNode *vn);
-static void freeAllVarNode(af_VarNode *vn);
-
-/* VarNode 相关操作 */
-static af_VarNode *findVarNode_(af_Var *var, const char *id);
-
-/* VarCup 创建与释放 */
-static af_VarCup *makeVarCup(af_Var *var);
-static af_VarCup *freeVarCup(af_VarCup *vp);
-static void freeAllVarCup(af_VarCup *vp);
-
-/* VarSpace 寻值函数 */
-static af_Var *findVarFromVarSpaceByIndex(time33_t index, const char *name, af_VarSpace *vs);
-
-/* 变量权限函数 */
-static bool checkVarReadPermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs);
-static bool checkVarWritePermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs);
-
-static af_VarNode *makeVarNode(af_Object *obj, const char *id) {
-    auto vn = calloc(1, af_VarNode);
-    if (id != nullptr)
-        vn->id = strCopy(id);
-    vn->obj = obj;
-    return vn;
-}
-
-static af_VarNode *freeVarNode(af_VarNode *vn) {
-    auto next = vn->next;
-    free(vn->id);
-    free(vn);
-    return next;
-}
-
-static void freeAllVarNode(af_VarNode *vn) {
-    while (vn != nullptr)
-        vn = freeVarNode(vn);
-}
-
-af_Var *makeVar(const char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_Environment *env){
-    auto vn = makeVarNode(obj, nullptr);
-    auto var = calloc(1, af_Var);
-    var->name = strCopy(name);
-    var->vn = vn;
-    var->permissions[0] = p_self;
-    var->permissions[1] = p_posterity;
-    var->permissions[2] = p_external;
-    pthread_rwlock_init(&var->lock, nullptr);
-    gc_addVar(var, env->base);
-    return var;
-}
-
-void freeVar(af_Var *var, af_Environment *env){
-    freeAllVarNode(var->vn);
-    free(var->name);
-    gc_delVar(var, env);
-    pthread_rwlock_destroy(&var->lock);
-    free(var);
-}
-
-/**
- * 查找指定名字的VarNode
- * 内部函数, 无锁
- * @param var
- * @param id
- * @return
- */
-static af_VarNode *findVarNode_(af_Var *var, const char *id) {
-    auto vn = var->vn->next;
-
-    if (id == nullptr)
-        return var->vn;
-
-    for(NULL; vn != nullptr; vn = vn->next) {
-        if (EQ_STR(vn->id, id))
-            return vn;
-    }
-    return nullptr;
-}
-
-void addVarNode(af_Var *var, af_Object *obj, const char *id) {
-    auto vn = makeVarNode(obj, id);
-    pthread_rwlock_wrlock(&var->lock);
-    vn->next = var->vn->next;  // 第一个 vn 必须为 id=nullptr
-    var->vn->next = vn;
-    pthread_rwlock_unlock(&var->lock);
-}
-
-/**
- * 查找指定名字的VarNode
- * 外部函数, 带锁
- * 返回值自动添加 gc_addReference
- * @param var
- * @param id
- * @return
- */
-af_Object *findVarNode(af_Var *var, const char *id, af_Environment *env){
-    pthread_rwlock_rdlock(&var->lock);
-    af_VarNode *vn = findVarNode_(var, id);
-    af_Object *obj = nullptr;
-    if (vn != nullptr) {
-        obj = vn->obj;
-        gc_addObjectReference(obj, env);
-    }
-    pthread_rwlock_unlock(&var->lock);
-    return obj;
-}
-
-static af_VarCup *makeVarCup(af_Var *var) {
-    auto vp = calloc(1, af_VarCup);
-    vp->var = var;
-    return vp;
-}
-
-static af_VarCup *freeVarCup(af_VarCup *vp) {
-    af_VarCup *next = vp->next;
-    free(vp);
-    return next;
-}
-
-static void freeAllVarCup(af_VarCup *vp) {
-    while (vp != nullptr)
-        vp = freeVarCup(vp);
-}
-
-af_VarSpace *makeVarSpace(af_Object *belong, char p_self, char p_posterity, char p_external, af_Environment *env){
-    assertFatalErrorLog(getCoreStatus(env) == core_creat || belong != nullptr, aFunCoreLogger, 1, "makeVarSpace error");
-    auto vs = calloc(1, af_VarSpace);
-    vs->belong = belong;
-    vs->permissions[0] = p_self;
-    vs->permissions[1] = p_posterity;
-    vs->permissions[2] = p_external;
-
-    pthread_rwlock_init(&vs->lock, nullptr);
-    gc_addVarSpace(vs, env->base);
-    return vs;
-}
-
-void freeVarSpace(af_VarSpace *vs, af_Environment *env) {
-    for (int i = 0; i < VAR_HASHTABLE_SIZE; i++)
-        freeAllVarCup(vs->var[i]);
-    gc_delVarSpace(vs, env);
-    pthread_rwlock_destroy(&vs->lock);
-    free(vs);
-}
-
-af_VarList *makeVarSpaceList(af_VarSpace *vs) {
-    auto vsl = calloc(1, af_VarList);
-    vsl->vs = vs;
-    return vsl;
-}
-
-af_VarList *copyVarSpaceList(af_VarList *vsl) {
-    af_VarList *base = nullptr;
-    af_VarList **pvsl = &base;
-    for(NULL; vsl != nullptr; vsl = vsl->next, pvsl = &((*pvsl)->next))
-        *pvsl = makeVarSpaceList(vsl->vs);
-    return base;
-}
-
-static af_VarList *freeVarSpaceList(af_VarList *vsl){
-    af_VarList *next = vsl->next;
-    free(vsl);
-    return next;
-}
-
-void freeAllVarSpaceList(af_VarList *vsl){
-    while (vsl != nullptr)
-        vsl = freeVarSpaceList(vsl);
-}
-
-af_VarSpace *getVarSpaceFromList(af_VarList *vsl) {
-    if (vsl != nullptr)
-        return vsl->vs;
-    return nullptr;
-}
-
-bool freeVarSpaceListCount(size_t count, af_VarList *vsl) {
-    for (size_t i = count; i > 0; i--) {
-        if (vsl == nullptr)  // 发生了错误
-            return false;
-        vsl = freeVarSpaceList(vsl);
-    }
-    return true;
-}
-
-/**
- * 检查访问者是否有定义变量的权限
- * 注意: 无锁, 由调用者加锁
- * @param visitor 访问者
- * @param vs 变量空间
- */
-static bool checkVarSpaceDefinePermissions(af_Object *visitor, af_VarSpace *vs){
-    char p = vs->permissions[2];  // 默认外部权限
-
-    af_ObjectData *belong_data = nullptr;
-    if (vs->belong != nullptr) {
-        pthread_rwlock_rdlock(&vs->belong->lock);
-        belong_data = vs->belong->data;
-        pthread_rwlock_unlock(&vs->belong->lock);
-    }
-
-    af_ObjectData *visitor_data;
-    if (visitor != nullptr) {
-        pthread_rwlock_rdlock(&visitor->lock);
-        visitor_data = visitor->data;
-        pthread_rwlock_unlock(&visitor->lock);
-    }
-
-    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
-        p = vs->permissions[0];
-    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
-        p = vs->permissions[1];
-
-    return p == 2 || p == 3;
-}
-
-/**
- * 把var添加到VarSpace中
- * 注意: Var必须添加 gc_addReference
- * @param var 变量
- * @param visitor 访问者
- * @param vs 变量空间
- * @return 若空间被保护, 权限错误或已存在同名Var则返回false不作修改 否则返回true
- */
-bool addVarToVarSpace(af_Var *var, af_Object *visitor, af_VarSpace *vs, af_Environment *env){
-    pthread_rwlock_rdlock(&var->lock);
-    pthread_rwlock_wrlock(&vs->lock);
-
-    time33_t index = time33(var->name) % VAR_HASHTABLE_SIZE;
-    af_VarCup **pCup = &vs->var[index];
-
-    if (vs->is_protect)
-        goto RETURN_FALSE;
-
-    if (!checkVarSpaceDefinePermissions(visitor, vs))
-        goto RETURN_FALSE;
-
-    for(NULL; *pCup != nullptr; pCup = &((*pCup)->next)) {
-        pthread_rwlock_wrlock(&(*pCup)->var->lock);
-        bool res = EQ_STR((*pCup)->var->name, var->name);
-        pthread_rwlock_unlock(&(*pCup)->var->lock);
-
-        if (res)
-            goto RETURN_FALSE;
-    }
-
-    *pCup = makeVarCup(var);
-    pthread_rwlock_unlock(&vs->lock);
-    pthread_rwlock_unlock(&var->lock);
-    gc_delVarReference(var, env);
-    return true;
-
-RETURN_FALSE:
-    pthread_rwlock_unlock(&vs->lock);
-    pthread_rwlock_unlock(&var->lock);
-    return false;
-}
-
-/**
- * 创建一个新的var添加到VarSpace中
- * 若已存在同名Var则返回false不作修改
- * 否则返回true
- * 调用 addVarToVarSpace
- * 注意: 必须保证 VarSpace被 gc 引用
- */
-bool makeVarToVarSpace(const char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_VarSpace *vs,
-                       af_Object *visitor, af_Environment *env){
-    af_Var *var = makeVar(name, p_self, p_posterity, p_external, obj, env);
-    if (addVarToVarSpace(var, visitor, vs, env))
-        return true;
-    gc_delVarReference(var, env);
-    return false;
-}
-
-/*
- * 函数名: makeVarToVarSpace
- * 目标: 添加一个Var到VarSpaceList
- * 自动跳过保护空间
- * 调用 addVarToVarSpace
- */
-bool addVarToVarSpaceList(af_Var *var, af_Object *visitor, af_VarList *vsl, af_Environment *env){
-    for(NULL; vsl != nullptr; vsl = vsl->next) {
-        if (!vsl->vs->is_protect)
-            return addVarToVarSpace(var, visitor, vsl->vs, env);
-    }
-    return false;
-}
-
-/**
- * 创建一个新的var到VarSpaceList
- * 自动跳过保护空间
- * 调用 addVarToVarSpaceList -> addVarToVarSpace
- * 注意: 必须保证 VarSpace被 gc 引用
- */
-bool makeVarToVarSpaceList(const char *name, char p_self, char p_posterity, char p_external, af_Object *obj,
-                           af_VarList *vsl, af_Object *visitor, af_Environment *env){
-    af_Var *var = makeVar(name, p_self, p_posterity, p_external, obj, env);
-    if (addVarToVarSpaceList(var, visitor, vsl, env))
-        return true;
-    gc_delVarReference(var, env);
-    return false;
-}
-
-/**
- * 创建一个新的var变量添加到保护空间中
- * 若已存在同名Var则返回false不作修改
- * 否则返回true
- * 调用 addVarToVarSpace
- */
-bool makeVarToProtectVarSpace(const char *name,
-                              char p_self, char p_posterity, char p_external,
-                              af_Object *obj, af_Environment *env){
-    pthread_rwlock_wrlock(&env->protect->lock);
-    bool is_protect = env->protect->is_protect;
-    env->protect->is_protect = false;
-    pthread_rwlock_unlock(&env->protect->lock);
-
-    af_Var *var = makeVar(name, p_self, p_posterity, p_external, obj, env);
-    bool ret = addVarToVarSpace(var, env->activity->belong, env->protect, env);
-    if (!ret)
-        gc_delVarReference(var, env);
-
-    pthread_rwlock_wrlock(&env->protect->lock);
-    env->protect->is_protect = is_protect;
-    pthread_rwlock_unlock(&env->protect->lock);
-    return ret;
-}
-
-/*
- * 函数名: addVarToProtectVarSpace
- * 目标: 添加一个var变量添加到保护空间中 (Var需要提前gc_addReference)
- * 若已存在同名Var则返回false不作修改
- * 否则返回true
- * 调用 addVarToVarSpace
- */
-bool addVarToProtectVarSpace(af_Var *var, af_Environment *env) {
-    pthread_rwlock_wrlock(&env->protect->lock);
-    bool is_protect = env->protect->is_protect;
-    env->protect->is_protect = false;
-    pthread_rwlock_unlock(&env->protect->lock);
-
-    bool re = addVarToVarSpace(var, nullptr, env->protect, env);
-
-    pthread_rwlock_wrlock(&env->protect->lock);
-    env->protect->is_protect = is_protect;
-    pthread_rwlock_unlock(&env->protect->lock);
-    return re;
-}
-
-
-/**
- * 检查访问者是否有删除变量的权限
- * 注意: 无锁, 由调用者加锁
- * @param visitor 访问者
- * @param vs 变量空间
- * @return
- */
-static bool checkVarSpaceDelPermissions(af_Object *visitor, af_VarSpace *vs) {
-    char p = vs->permissions[2];  // 默认外部权限
-
-    af_ObjectData *belong_data = nullptr;
-    if (vs->belong != nullptr) {
-        pthread_rwlock_rdlock(&vs->belong->lock);
-        belong_data = vs->belong->data;
-        pthread_rwlock_unlock(&vs->belong->lock);
-    }
-
-    af_ObjectData *visitor_data;
-    if (visitor != nullptr) {
-        pthread_rwlock_rdlock(&visitor->lock);
-        visitor_data = visitor->data;
-        pthread_rwlock_unlock(&visitor->lock);
-    }
-
-    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
-        p = vs->permissions[0];
-    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
-        p = vs->permissions[1];
-
-    return p == 1 || p == 3;
-}
-
-/*
- * 函数名: delVarFromVarSpace
- * 目标: 从VarSpace中删除指定的变量
- * 若空间被保护, 权限错误或已存在同名Var则返回false不作修改
- * 否则返回true
- */
-bool delVarFromVarSpace(const char *name, af_Object *visitor, af_VarSpace *vs) {
-    time33_t index = time33(name) % VAR_HASHTABLE_SIZE;
-
-    pthread_rwlock_wrlock(&vs->lock);
-    af_VarCup **pCup = &vs->var[index];
-
-    if (vs->is_protect)
-        goto RETRUN_FALSE;
-
-    if (!checkVarSpaceDelPermissions(visitor, vs))
-        goto RETRUN_FALSE;
-
-    for(NULL; *pCup != nullptr; pCup = &((*pCup)->next)) {
-        pthread_rwlock_wrlock(&(*pCup)->var->lock);
-
-        if (EQ_STR((*pCup)->var->name, name)) {
-            *pCup = freeVarCup(*pCup);
-            pthread_rwlock_unlock(&(*pCup)->var->lock);
-            pthread_rwlock_unlock(&vs->lock);
-            return true;
-        }
-
-        pthread_rwlock_unlock(&(*pCup)->var->lock);
-    }
-
-RETRUN_FALSE:
-    pthread_rwlock_unlock(&vs->lock);
-    return false;
-}
-
-/*
- * 函数名: delVarFromVarList
- * 目标: 从VarSpaceList中第一层的VarSpace中删除指定的变量
- * 若空间被保护, 权限错误或已存在同名Var则返回false不作修改
- * 否则返回true
- * 调用delVarFromVarSpace
- */
-bool delVarFromVarList(const char *name, af_Object *visitor, af_VarList *vsl) {
-    return delVarFromVarSpace(name, visitor, vsl->vs);
-}
-
-/*
- * 函数名: findVarFromVarSpaceByIndex
- * 目标: 根据指定的index, 在VarSpace中搜索var
- * 权限检查交给 findVarFromVarSpace 和 findVarFromVarList
- */
-static af_Var *findVarFromVarSpaceByIndex(time33_t index, const char *name, af_VarSpace *vs) {
-    pthread_rwlock_rdlock(&vs->lock);
-    for (af_VarCup *cup = vs->var[index]; cup != nullptr; cup = cup->next) {
-        pthread_rwlock_wrlock(&cup->var->lock);
-
-        if (EQ_STR(cup->var->name, name)) {
-            af_Var *var = cup->var;
-            pthread_rwlock_unlock(&cup->var->lock);
-            pthread_rwlock_unlock(&vs->lock);
-            return var;
-        }
-
-        pthread_rwlock_unlock(&cup->var->lock);
-    }
-    pthread_rwlock_unlock(&vs->lock);
-    return nullptr;
-}
-
-/**
- * 检查访问者是否有读取变量的权限
- * 注意: 会给VarSpace和Var加读锁
- * @param var 变量
- * @param visitor 访问者
- * @param vs  变量空间
- * @return 返回是否具有读取权限
- */
-static bool checkVarReadPermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs){
-    char p = var->permissions[2];  // 默认外部权限
-
-    pthread_rwlock_rdlock(&vs->lock);
-    pthread_rwlock_rdlock(&var->lock);
-
-    af_ObjectData *belong_data = nullptr;
-    if (vs->belong != nullptr) {
-        pthread_rwlock_rdlock(&vs->belong->lock);
-        belong_data = vs->belong->data;
-        pthread_rwlock_unlock(&vs->belong->lock);
-    }
-
-    af_ObjectData *visitor_data;
-    if (visitor != nullptr) {
-        pthread_rwlock_rdlock(&visitor->lock);
-        visitor_data = visitor->data;
-        pthread_rwlock_unlock(&visitor->lock);
-    }
-
-    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
-        p = var->permissions[0];
-    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
-        p = var->permissions[1];
-
-    pthread_rwlock_unlock(&vs->lock);
-    pthread_rwlock_unlock(&var->lock);
-    return p == 1 || p == 3;
-}
-
-/*
- * 函数名: findVarFromVarSpace
- * 目标: 在VarSpace中搜索var
- * 调用: findVarFromVarSpaceByIndex
- */
-af_Var *findVarFromVarSpace(const char *name, af_Object *visitor, af_VarSpace *vs){
-    af_Var *var = findVarFromVarSpaceByIndex(time33(name) % VAR_HASHTABLE_SIZE, name, vs);
-    if (var == nullptr)
-        return nullptr;
-
-    if (checkVarReadPermissions(var, visitor, vs))
-        return var;
-    return nullptr;
-}
-
-/*
- * 函数名: findVarFromVarList
- * 目标: 在VarSpaceListNode中搜索var
- * 调用: findVarFromVarSpaceByIndex
- */
-af_Var *findVarFromVarList(const char *name, af_Object *visitor, af_VarList *vsl) {
-    time33_t index = time33(name) % VAR_HASHTABLE_SIZE;
-
-    for(NULL; vsl != nullptr; vsl = vsl->next) {
-        af_Var *var = findVarFromVarSpaceByIndex(index, name, vsl->vs);
-        if (var != nullptr) {
-            if (checkVarReadPermissions(var, visitor, vsl->vs))
-                return var;
-            return nullptr;
-        }
-    }
-
-    return nullptr;
-}
-
-/**
- * 检查访问者是否有改写变量的权限
- * 注意: 不会给VarList加锁, 给Var加读锁, 由调用者加锁
- * @param var 变量
- * @param visitor 访问者
- * @param vs 变量空间
- * @return
- */
-static bool checkVarWritePermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs){
-    char p = var->permissions[2];  // 默认外部权限
-
-    af_ObjectData *belong_data = nullptr;
-    if (vs->belong != nullptr) {
-        pthread_rwlock_rdlock(&vs->belong->lock);
-        belong_data = vs->belong->data;
-        pthread_rwlock_unlock(&vs->belong->lock);
-    }
-
-    af_ObjectData *visitor_data;
-    if (visitor != nullptr) {
-        pthread_rwlock_rdlock(&visitor->lock);
-        visitor_data = visitor->data;
-        pthread_rwlock_unlock(&visitor->lock);
-    }
-
-    pthread_rwlock_rdlock(&vs->lock);
-    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
-        p = var->permissions[0];
-    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
-        p = var->permissions[1];
-    pthread_rwlock_unlock(&vs->lock);
-
-    return p == 2 || p == 3;
-}
-
-/*
- * 函数名: setVarToVarSpace
- * 目标: 在VarSpace中搜索var并修改其值
- * 调用: findVarFromVarSpaceByIndex
- */
-bool setVarToVarSpace(const char *name, af_Object *obj, af_Object *visitor, af_VarSpace *vs){
-    af_Var *var = findVarFromVarSpaceByIndex(time33(name) % VAR_HASHTABLE_SIZE, name, vs);
-    if (var == nullptr)
-        return false;
-
-    pthread_rwlock_wrlock(&vs->lock);
-    if (checkVarWritePermissions(var, visitor, vs)) {
-        pthread_rwlock_unlock(&vs->lock);
-
-        pthread_rwlock_wrlock(&var->lock);
-        var->vn->obj = obj;
-        pthread_rwlock_unlock(&var->lock);
-        return true;
-    }
-
-    pthread_rwlock_unlock(&vs->lock);
-    return false;
-}
-
-/*
- * 函数名: setVarToVarList
- * 目标: 在VarSpaceListNode中搜索var并修改其值
- * 调用: findVarFromVarSpaceByIndex
- */
-bool setVarToVarList(const char *name, af_Object *obj, af_Object *visitor, af_VarList *vsl) {
-    time33_t index = time33(name) % VAR_HASHTABLE_SIZE;
-    af_Var *var;
-
-    for(NULL; vsl != nullptr; vsl = vsl->next) {
-        var = findVarFromVarSpaceByIndex(index, name, vsl->vs);
-        if (var != nullptr) {
-            pthread_rwlock_wrlock(&vsl->vs->lock);
-            if (checkVarWritePermissions(var, visitor, vsl->vs)) {
-                pthread_rwlock_unlock(&vsl->vs->lock);
-
-                pthread_rwlock_wrlock(&var->lock);
-                var->vn->obj = obj;
-                pthread_rwlock_unlock(&var->lock);
-
-                return true;
-            }
-            pthread_rwlock_unlock(&vsl->vs->lock);
-            return false;
-        }
-    }
-    return false;
-}
-
-/**
- * 压入新的空VarSpace
- * 并且保留gc计数
- * @param belong
- * @param base
- * @param env
- * @return
- */
-af_VarList *pushNewVarList(af_Object *belong, af_VarList *base, af_Environment *env){
-    af_VarSpace *vs = makeVarSpace(belong, 3, 2, 0, env);
-    af_VarList *new_vs = makeVarSpaceList(vs);
-    new_vs->next = base;
-    return new_vs;
-}
-
-/**
- * 压入新的空保护空间的VarSpace
- * @param belong
- * @param base
- * @param env
- * @return
- */
-af_VarList *pushProtectVarList(af_VarList *base, af_Environment *env){
-    af_VarList *new_vsl = makeVarSpaceList(getProtectVarSpace(env));
-    new_vsl->next = base;
-    return new_vsl;
-}
-
-af_VarList *pushVarList(af_VarSpace *vs, af_VarList *base){
-    af_VarList *new_vsl = makeVarSpaceList(vs);
-    new_vsl->next = base;
-    return new_vsl;
-}
-
-void setVarPermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs, char p_self, char p_posterity, char p_external) {
-    pthread_rwlock_rdlock(&vs->lock);
-
-    af_ObjectData *belong_data = nullptr;
-    if (vs->belong != nullptr) {
-        pthread_rwlock_rdlock(&vs->belong->lock);
-        belong_data = vs->belong->data;
-        pthread_rwlock_unlock(&vs->belong->lock);
-    }
-
-    af_ObjectData *visitor_data = nullptr;
-    if (visitor != nullptr) {
-        pthread_rwlock_rdlock(&visitor->lock);
-        visitor_data = visitor->data;
-        pthread_rwlock_unlock(&visitor->lock);
-    }
-
-    pthread_rwlock_unlock(&vs->lock);
-
-    if (belong_data != nullptr && belong_data != visitor_data)
-        return;
-
-    pthread_rwlock_wrlock(&var->lock);
-    var->permissions[0] = p_self;
-    var->permissions[1] = p_posterity;
-    var->permissions[2] = p_external;
-    pthread_rwlock_unlock(&var->lock);
-}
-
-void setVarSpacePermissions(af_Object *visitor, af_VarSpace *vs, char p_self, char p_posterity, char p_external) {
-    pthread_rwlock_rdlock(&vs->lock);
-
-    af_ObjectData *belong_data = nullptr;
-    if (vs->belong != nullptr) {
-        pthread_rwlock_rdlock(&vs->belong->lock);
-        belong_data = vs->belong->data;
-        pthread_rwlock_unlock(&vs->belong->lock);
-    }
-
-    af_ObjectData *visitor_data = nullptr;
-    if (visitor != nullptr) {
-        pthread_rwlock_rdlock(&visitor->lock);
-        visitor_data = visitor->data;
-        pthread_rwlock_unlock(&visitor->lock);
-    }
-
-    pthread_rwlock_unlock(&vs->lock);
-
-    if (belong_data != nullptr && belong_data != visitor_data)
-        return;
-
-    vs->permissions[0] = p_self;
-    vs->permissions[1] = p_posterity;
-    vs->permissions[2] = p_external;
-}
-
-bool isProtectVarSpace(af_VarSpace *vs) {
-    pthread_rwlock_rdlock(&vs->lock);
-    bool res = vs->is_protect;
-    pthread_rwlock_unlock(&vs->lock);
-    return res;
-}
-
-bool setVarSpaceProtect(af_Object *visitor, af_VarSpace *vs, bool protect) {
-    pthread_rwlock_wrlock(&vs->lock);
-    bool re = vs->is_protect;
-
-    af_ObjectData *belong_data = nullptr;
-    if (vs->belong != nullptr) {
-        pthread_rwlock_rdlock(&vs->belong->lock);
-        belong_data = vs->belong->data;
-        pthread_rwlock_unlock(&vs->belong->lock);
-    }
-
-    af_ObjectData *visitor_data = nullptr;
-    if (visitor != nullptr) {
-        pthread_rwlock_rdlock(&visitor->lock);
-        visitor_data = visitor->data;
-        pthread_rwlock_unlock(&visitor->lock);
-    }
-
-    if (belong_data != nullptr && belong_data != visitor_data) {
-        pthread_rwlock_unlock(&vs->lock);
-        return re;
-    }
-
-    vs->is_protect = protect;
-    pthread_rwlock_unlock(&vs->lock);
-    return re;
-}

src/main.cpp

@@ -1,409 +0,0 @@
-#include <cstdio>
-#include <cstdlib>
-#include "aFun.hpp"
-#include "main.hpp"
-#include "main_run.hpp"
-#include "main_build.hpp"
-
-ff_defArg(help, false)
-                ff_argRule('h', help, not, 'h')
-                ff_argRule('v', version, not, 'v')
-ff_endArg(help, false);
-
-ff_selfProcessChild(run, true);
-
-ff_defArg(cl, false)
-                ff_argRule('e', eval, must, 'e')
-                ff_argRule('f', file, must, 'f')
-                ff_argRule('s', source, must, 's')
-                ff_argRule('b', byte, must, 'b')
-                ff_argRule(NUL, no-aub, not, 'a')
-                ff_argRule(NUL, no-cl, not, 'n')
-                ff_argRule(NUL, no-import, not, 'o')
-                ff_argRule(NUL, import, not, 'i')
-ff_endArg(cl, false);
-
-ff_defArg(build, false)
-                ff_argRule('o', out, must, 'o')
-                ff_argRule('p', path, must, 'p')
-                ff_argRule('f', fource, not, 'f')
-ff_endArg(build, false);
-
-// exe 是指可执行程序, 而非仅PE的可执行程序
-ff_childList(aFunlang_exe, ff_child(run), ff_child(help), ff_child(cl), ff_child(build));
-
-static const char *name = nullptr;
-
-static int mainHelp(ff_FFlags *ff);
-static void printVersion();
-static void printHelp();
-static bool stdin_interrupt(int f);
-static int mainRun(ff_FFlags *ff);
-static int mainCL(ff_FFlags *ff);
-static int mainBuild(ff_FFlags *ff);
-
-char *base_path = nullptr;
-static Logger aFunlangLogger_;
-Logger *aFunlangLogger = &aFunlangLogger_;
-static bool tty_stdin = false;
-
-void freeBaseName(void *_) {
-    free(base_path);
-}
-
-#ifdef aFunWIN32_NO_CYGWIN
-
-int argc_s = 0;
-char **argv_s = nullptr;
-
-void convertArgs(int argc, char *argv_ansi[]) {
-    argc_s = argc;
-    argv_s = calloc((size_t)argc, char *);
-    for(int i = 0; i < argc; i++) {
-        if (convertMultiByte(argv_s + i, argv_ansi[i], CP_ACP, CP_UTF8) == 0) {
-            fputs_std_("参数转换错误", stderr);
-            exit(EXIT_FAILURE);
-        }
-    }
-}
-
-void convertArgsFree() {
-    for(int i = 0; i < argc_s; i++)
-        free(argv_s[i]);
-    free(argv_s);
-}
-
-int main(int argc, char **argv_ansi) {
-    convertArgs(argc, argv_ansi);
-    char **argv = argv_s;
-#else
-int main(int argc, char **argv) {
-#endif
-    jmp_buf main_buf;
-    tty_stdin = isatty(fileno(stdin));
-    base_path = getExedir(1);
-    if (base_path == nullptr) {
-        printf_stderr(0, "aFunlang init error.");
-        aFunExit(aFunExitFail);
-    }
-
-    aFunAtExit(freeBaseName, nullptr);
-    if (setjmp(main_buf) == 1)
-        aFunExit(2);
-
-    aFunInitInfo info = {.base_dir=base_path,
-                         .log_asyn=true,
-                         .buf=&main_buf,
-#ifdef aFunDEBUG
-                         .level=log_debug,
-#else
-                         .level=log_info,
-#endif
-    };
-
-    ff_FFlags *ff = ff_initFFlags(argc, argv, true, false, stderr, aFunlang_exe);
-    if (ff == nullptr)
-        aFunExit(aFunExitFail);
-
-    if (!aFunInit(&info)) {
-        printf_stderr(0, "aFunlang init error.");
-        aFunExit(aFunExitFail);
-    }
-
-    initLogger(aFunlangLogger, "aFunlang-exe", info.level);
-    aFunlangLogger->buf = &main_buf;
-    writeDebugLog(aFunlangLogger, "aFunlang-exe init success: %s", (tty_stdin ? "tty" : "no-tty"));
-
-    int exit_code = EXIT_SUCCESS;
-    const char *child = ff_getChild(ff);
-    name = *argv;  // 获取第一个参数为name
-
-    if (EQ_STR(child, "cl"))
-        exit_code = mainCL(ff);
-    else if (EQ_STR(child, "build"))
-        exit_code = mainBuild(ff);
-    else if (EQ_STR(child, "run"))
-        exit_code = mainRun(ff);
-    else
-        exit_code = mainHelp(ff);
-
-    ff_freeFFlags(ff);
-    aFunDestruct();
-    aFunExit(exit_code);
-}
-
-static void printVersion() {
-    /* Version的显示不被翻译, 因为它通常还需要被其他程序读取而进行处理, 必须保证一致性 */
-    printf_stdout(0, "aFunlang at  %s\n", name);
-    printf_stdout(0, "aFunlang dir %s\n", base_path);
-    fputs_stdout("version: " aFunVersion "\n");
-    fputs_stdout(aFunDescription"\n");
-}
-
-static void printWelcomeInfo() {
-    printf_stdout(0, "aFunlang " aFunVersion " %s (" __DATE__ ", " __TIME__ ")\n", HT_aFunGetText(command_line_n, "CommandLine"));
-    fputs_stdout("[" compilerID "] on " systemName "\n");
-    printf_stdout(0, "(%s)\n", HT_aFunGetText(command_line_tips, "Enter the aFun code to run in the top activity"));
-}
-
-static void printHelp() {
-    printf_stdout(0, "aFunlang %s:\n", HT_aFunGetText(usage_n, "Usage"));
-    printf_stdout(0, "%s\n", HT_aFunGetText(help_info, "<base-tr>"));
-}
-
-/*
- * 函数名: printError
- * 目标: 打印参数错误信息
- */
-static void printError(ff_FFlags *ff) {
-    writeErrorLog(aFunlangLogger, "%s argument error", ff_getChild(ff));
-    printf_stdout(0, "%s (%s)\n", HT_aFunGetText(cl_arg_error_e, "Command line argument error"), ff_getChild(ff));
-    printHelp();
-}
-
-static int mainHelp(ff_FFlags *ff) {
-    char *text = nullptr;
-    int mark;
-    bool have_opt = false;
-    /* 无信号处理 */
-
-    while (true) {
-        mark = ff_getopt(&text, ff);
-
-        switch (mark) {
-            case 'h':
-                printHelp();
-                break;
-            case 'v':
-                printVersion();
-                break;
-            case -1:
-                goto out;
-            default:
-                printError(ff);
-                return EXIT_FAILURE;
-        }
-
-        have_opt = true;  // 表示有实际参数
-    }
-out:
-    if (!have_opt) {
-        printHelp();
-        return EXIT_SUCCESS;
-    }
-
-    return EXIT_SUCCESS;
-}
-
-static int mainRun(ff_FFlags *ff) {
-    int exit_code;
-    char **argv = nullptr;
-    int argc = ff_get_process_argv(&argv, ff);
-    af_Environment *env;
-    aFunRunInfo ri = {.signal=true};
-    defineRunEnv(&ri);
-
-    if (argc == 0) {
-        /* 进入命令行模式 */
-        if (!tty_stdin)
-            return 0;
-        env = creatAFunEnvironment(0, nullptr);
-        printWelcomeInfo();
-        do {
-            if (ferror(stdin) || feof(stdin)) {  // 错误应在实际程序中处理, 若在此仍处于错误状态则直接返回
-                writeErrorLog(aFunlangLogger, "stdin error/eof");
-                break;
-            }
-            runCodeFromStdin("stdin", env);
-        } while (isCoreExit(env) != 1);
-        exit_code = getCoreExitCode(env);
-        destructAFunEnvironment(env);
-    } else {
-        env = creatAFunEnvironment(argc - 1, argv + 1);
-        exit_code = runCodeFromFile(argv[0], true, 0, env);
-        destructAFunEnvironment(env);
-    }
-
-    undefRunEnv(&ri);
-    writeInfoLog(aFunlangLogger, "aFun exit code: %d", exit_code);
-    printf_stdout(0, "aFun %s: %d\n", HT_aFunGetText(exit_code_n, "exit code"), exit_code);
-
-    return exit_code;
-}
-
-static RunList *getRunList(ff_FFlags *ff, bool *command_line, bool *save_aub) {
-    char *text = nullptr;
-    RunList *run_list = nullptr;
-    RunList **prl = &run_list;
-    int mark;
-    bool import = true;
-
-    *command_line = true;
-    *save_aub = true;
-
-    while (true) {
-        mark = ff_getopt(&text, ff);
-        switch (mark) {
-            case 'e':
-                prl = pushRunList(makeStringRunList(text, import), prl);
-                break;
-            case 'f':
-                prl = pushRunList(makeFileRunList(text, import), prl);
-                break;
-            case 's':
-                prl = pushRunList(makeFileSourceRunList(text), prl);
-                break;
-            case 'b':
-                prl = pushRunList(makeFileByteRunList(text), prl);
-                break;
-            case 'n':
-                *command_line = false;
-                break;
-            case 'a':
-                *save_aub = false;
-                break;
-            case 'o':
-                import = false;
-                break;
-            case 'i':
-                import = true;
-                break;
-            case -1:
-                goto out;
-            default:
-                *command_line = false;  // 命令行也不启动
-                printError(ff);
-                freeAllRunList(run_list);
-                return nullptr;
-        }
-    }
-
-out:
-    while (ff_getopt_wild_before(&text, ff))
-        prl = pushRunList(makeFileRunList(text, true), prl);
-    return run_list;
-}
-
-static int mainCL(ff_FFlags *ff) {
-    bool command_line = true;
-    bool save_aub = true;
-    int exit_code;
-    RunList *rl = getRunList(ff, &command_line, &save_aub);
-
-    if (rl == nullptr && !command_line) {
-        writeErrorLog(aFunlangLogger, "CL not file to run");
-        printf_stderr(0, "%s\n", HT_aFunGetText(cl_not_file_e, "There are not file run"));
-        return EXIT_FAILURE;
-    }
-
-    int argc = 0;
-    char *text;
-    while (ff_getopt_wild_after(&text, ff))
-        argc++;
-
-    char **argv = calloc(argc, char *);
-    for (int i = 0; ff_getopt_wild_after(&text, ff); i++)
-        argv[i] = text;
-
-    af_Environment *env = creatAFunEnvironment(argc, argv);
-    aFunRunInfo ri = {.signal=true};
-    defineRunEnv(&ri);  // 由aFunCore提前接管
-
-    if (rl != nullptr)
-        runCodeFromRunList(rl, nullptr, save_aub, env);
-
-    if (tty_stdin && command_line && isCoreExit(env) != 1) {
-        printWelcomeInfo();
-        do {
-            if (ferror(stdin) || feof(stdin)) {  // 错误应在实际程序中处理, 若在此仍处于错误状态则直接返回
-                writeErrorLog(aFunlangLogger, "stdin error/eof");
-                break;
-            }
-            runCodeFromStdin("stdin", env);
-        } while (isCoreExit(env) != 1);
-    }
-
-    exit_code = getCoreExitCode(env);
-    writeInfoLog(aFunlangLogger, "aFun exit code: %d", exit_code);
-    printf_stdout(0, "aFun %s: %d\n", HT_aFunGetText(exit_code_n, "exit code"), exit_code);
-
-    undefRunEnv(&ri);
-    destructAFunEnvironment(env);
-    freeAllRunList(rl);
-    free(argv);
-    return exit_code;
-}
-
-static int mainBuild(ff_FFlags *ff) {
-    char *text = nullptr;
-    char *out_put = nullptr;
-    char *path = nullptr;
-    bool force = false;
-    int mark;
-    int exit_code = 0;
-
-    while (true) {
-        mark = ff_getopt(&text, ff);
-
-        switch (mark) {
-            case 'o':
-                if (path != nullptr) {
-                    writeErrorLog(aFunlangLogger, "Build argument conflict");
-                    printf_stderr(0, "%s (--out, --path)\n", HT_aFunGetText(arg_conflict_n, "Argument conflict"));
-                    goto error;
-                }
-                out_put = text;
-                break;
-            case 'p':
-                if (out_put != nullptr) {
-                    writeErrorLog(aFunlangLogger, "Build argument conflict");
-                    printf_stderr(0, "%s (--out, --path)\n", HT_aFunGetText(arg_conflict_n, ""));
-                    goto error;
-                }
-                path = text;
-                break;
-            case 'f':
-                force = true;
-                break;
-            case -1:
-                goto out;
-            default:
-                goto error;
-        }
-    }
-
-out:
-    if (out_put != nullptr) {
-        FilePath in;
-
-        /* 如果没有参数 */
-        if (!ff_getopt_wild(&text, ff)) {
-            writeErrorLog(aFunlangLogger, "Build not source file");
-            printf_stderr(0, "%s\n", HT_aFunGetText(build_not_src_e, "There are not source file to build"));
-            goto error;
-        } else
-            in = text;
-
-        /* 如果还有第二个参数 */
-        if (ff_getopt_wild(&text, ff)) {
-            writeErrorLog(aFunlangLogger, "Build too many source file");
-            printf_stderr(0, "%s\n", HT_aFunGetText(build_many_src_e, "There are too many source file to build (Do not use --out option)"));
-            goto error;
-        }
-
-        return buildFileOutput(out_put, in, force);
-    } else if (path != nullptr) {
-        while (ff_getopt_wild(&text, ff) && exit_code == 0)
-            exit_code = buildFileToPath(path, text, force);
-        return exit_code;
-    }
-
-    while (ff_getopt_wild(&text, ff) && exit_code == 0)
-        exit_code = buildFileToSelf(text, force);
-
-    return exit_code;
-
-error:
-    printError(ff);
-    return EXIT_FAILURE;
-}

src/main_build.cpp

@@ -1,46 +0,0 @@
-#include "aFun.hpp"
-#include "main_build.hpp"
-
-int buildFileOutput(FilePath out, FilePath in, bool force) {
-    if (!force) {
-        time_t time_1 = getFileMTime(in);
-        time_t time_2 = getFileMTime(out);
-
-        if (time_1 == 0 && time_2 == 0) {
-            writeErrorLog(aFunlangLogger, "Source not exists: %s", in);
-            printf_stderr(0, "%s [%s]\n", HT_aFunGetText(build_src_not_exists_e, "Source not exists"), in);
-            return -1;
-        }
-
-        if (time_2 >= time_1) {
-            writeWarningLog(aFunlangLogger, "Source already build %s", in);
-            printf_stderr(0, "%s (%s), %s\n", HT_aFunGetText(build_src_already, "Source already build"), in, HT_aFunGetText(build_use_f, "use --force to build again"));
-            return 0;
-        }
-    }
-
-    writeInfoLog(aFunlangLogger, "Build %s, %s",  in, out);
-    printf_stdout(0, "%s (%s -> %s)\n", HT_aFunGetText(build_file, "Source will be build"), in, out);
-    return buildFile(out, in);
-}
-
-int buildFileToPath(FilePath path, FilePath in, bool force) {
-    char *name = getFileName(in);
-    char *out = joinPath(path, name, ".aub");
-
-    int res = buildFileOutput(out, in, force);
-
-    free(name);
-    free(out);
-    return res;
-}
-
-int buildFileToSelf(FilePath in, bool force) {
-    char *path = getFileNameWithPath(in);
-    char *out = strJoin(path, ".aub", true, false);
-
-    int res = buildFileOutput(out, in, force);
-
-    free(out);
-    return res;
-}

src/main_build.hpp

@@ -1,9 +0,0 @@
-#ifndef AFUN_MAIN_BUILD_H_
-#define AFUN_MAIN_BUILD_H_
-#include "main.hpp"
-
-int buildFileOutput(FilePath out, FilePath in, bool force);
-int buildFileToPath(FilePath path, FilePath in, bool force);
-int buildFileToSelf(FilePath in, bool force);
-
-#endif //AFUN_MAIN_BUILD_H_

src/main_run.cpp

@@ -1,87 +0,0 @@
-#include "aFun.hpp"
-#include "main_run.hpp"
-
-
-static RunList *makeRunList(bool import){
-    auto run_list = calloc(1, RunList);
-    run_list->import = import;
-    return run_list;
-}
-
-static RunList *freeRunList(RunList *rl) {
-    RunList *next = rl->next;
-    if (rl->type == rl_file_s || rl->type == rl_file_b || rl->type == rl_file)
-        free(rl->file);
-    else
-        free(rl->string);
-    free(rl);
-    return next;
-}
-
-void freeAllRunList(RunList *rl) {
-    while(rl != nullptr)
-        rl = freeRunList(rl);
-}
-
-RunList *makeFileRunList(FilePath file, bool import){
-    RunList *rl = makeRunList(import);
-    rl->type = rl_file;
-    rl->file = strCopy(file);
-    return rl;
-}
-
-RunList *makeFileSourceRunList(FilePath file){
-    RunList *rl = makeFileRunList(file, true);
-    rl->type = rl_file_s;
-    return rl;
-}
-
-RunList *makeFileByteRunList(FilePath file){
-    RunList *rl = makeFileRunList(file, true);
-    rl->type = rl_file_b;
-    return rl;
-}
-
-RunList *makeStringRunList(char *string, bool import){
-    RunList *rl = makeRunList(import);
-    rl->type = rl_string;
-    rl->string = strCopy(string);
-    return rl;
-}
-
-RunList **pushRunList(RunList *rl, RunList **base) {
-    while (*base != nullptr)
-        base = &((*base)->next);
-    *base = rl;
-    while (*base != nullptr)
-        base = &((*base)->next);
-    return base;
-}
-
-int runCodeFromRunList(RunList *run_list, RunList **bak, bool save_afb, af_Environment *env) {
-    int exit_code = 0;
-
-    for(NULL; run_list != nullptr; run_list = run_list->next) {
-        int mode = run_list->import ? 1 : 0;
-        switch (run_list->type) {
-            case rl_string:
-                exit_code = runCodeFromString(run_list->string, "command-line-eval", mode, env);
-                break;
-            case rl_file:
-                exit_code = runCodeFromFile(run_list->file, save_afb, mode, env);
-                break;
-            case rl_file_b:
-                exit_code = runCodeFromFileByte(run_list->file, mode, env);
-                break;
-            case rl_file_s:
-                exit_code = runCodeFromFileSource(run_list->file, save_afb, nullptr, mode, env);
-                break;
-            default:
-                break;
-        }
-    }
-
-    if (bak != nullptr)
-        *bak = run_list;
-    return exit_code;
-}

src/main_run.hpp

@@ -1,34 +0,0 @@
-#ifndef AFUN_MAIN_RUN_H_
-#define AFUN_MAIN_RUN_H_
-#include "main.hpp"
-
-enum RunListType {
-    rl_file,
-    rl_file_s,
-    rl_file_b,
-    rl_string
-};
-
-typedef struct RunList RunList;
-struct RunList {
-    enum RunListType type;
-
-    union {
-        FilePath file;
-        char *string;
-    };
-
-    bool import;
-    struct RunList *next;
-};
-
-RunList *makeFileRunList(FilePath file, bool import);
-RunList *makeFileByteRunList(FilePath file);
-RunList *makeFileSourceRunList(FilePath file);
-RunList *makeStringRunList(char *string, bool import);
-void freeAllRunList(RunList *rl);
-RunList **pushRunList(RunList *rl, RunList **base);
-
-int runCodeFromRunList(RunList *run_list, RunList **bak, bool save_afb, af_Environment *env);
-
-#endif //AFUN___MAIN_RUN_H

src/runtime/__aFunlang.hpp

@@ -1,5 +0,0 @@
-#ifndef AFUN_AFUNLANG_H_
-#define AFUN_AFUNLANG_H_
-#include "aFunlang.hpp"
-
-#endif //AFUN_AFUNLANG_H_

src/runtime/__cycle_obj.hpp

@@ -1,6 +0,0 @@
-#ifndef AFUN___CYCLE_OBJ_HPP
-#define AFUN___CYCLE_OBJ_HPP
-#include "aFunlangExport.h"
-
-AFUN_LANG_NO_EXPORT af_Object *makeCycleObject(af_Environment *env);
-#endif //AFUN___CYCLE_OBJ_HPP

src/runtime/__runtime.hpp

@@ -1,18 +0,0 @@
-#ifndef AFUN_RUNTIME_H_
-#define AFUN_RUNTIME_H_
-#include "aFunlang.hpp"
-#include "runtime.hpp"
-#include "__env.hpp"
-
-/*
- * 返回 (0/1) 执行正常
- * 返回 其他执行错误
- */
-typedef int aFunToolFunction(af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-typedef struct ToolFunc ToolFunc;
-struct ToolFunc {
-    const char *name;
-    aFunToolFunction *func;
-};
-
-#endif //AFUN_AFUN_TOOL_H_

src/runtime/aFunlang.cpp

@@ -1,421 +0,0 @@
-#include "aFunCore.hpp"
-#include "__aFunlang.hpp"
-#include "__env.hpp"
-#include "__cycle_obj.hpp"
-
-#ifdef aFunWIN32_NO_CYGWIN
-#include <io.h>
-#define fileno _fileno
-#define isatty _isatty
-#else
-#include "unistd.h"
-#endif
-
-static int runCode_(af_Parser *parser, int mode, FilePath save_path, af_Environment *env);
-static bool aFunInit_mark = false;
-
-typedef struct guardian_GC_data guardian_GC_data;
-struct guardian_GC_data{
-    time_t last_time;
-};
-
-/* 内置守护器 */
-static bool checkSignal(int signum,
-                        const char *sig, const char *sigcfg, const char *sigerr, char err[],
-                        af_Environment *env);
-static af_GuardianList *guardian_GC(char *type, bool is_guard, guardian_GC_data *data, af_Environment *env);
-static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, af_Environment *env);
-
-bool aFunInit(aFunInitInfo *info) {
-    if (aFunInit_mark)
-        return false;
-
-    if (info == nullptr) {
-        static aFunInitInfo info_default = {
-                .base_dir=".",
-                .log_asyn=true,
-                .buf=nullptr,
-                .level=log_info
-        };
-        info = &info_default;
-    }
-
-    aFunCoreInitInfo core_info = {.base_dir=info->base_dir,
-                                  .log_asyn=info->log_asyn,
-                                  .buf=info->buf,
-                                  .level=info->level};
-
-    aFunInit_mark = aFunCoreInit(&core_info);
-    if (aFunInit_mark)
-        writeDebugLog(aFunCoreLogger, "aFun-runtime Init success");
-    return aFunInit_mark;
-}
-
-bool aFunDestruct() {
-    return aFunCoreDestruct();
-}
-
-/*
- * 函数名: defineRunEnv
- * 目标: 运行前的初始化
- */
-void defineRunEnv(aFunRunInfo *run_env) {
-    aFunRunCoreInfo core_info = {.signal=run_env->signal};
-    defineRunEnvCore(&core_info);
-}
-
-/*
- * 函数名: undefRunEnv
- * 目标: 取消运行前的初始化
- */
-void undefRunEnv(aFunRunInfo *run_env) {
-    aFunRunCoreInfo core_info = {.signal=run_env->signal};
-    undefRunEnvCore(&core_info);
-}
-
-
-static bool checkSignal(int signum,
-                        const char *sig, const char *sigcfg, const char *sigerr, char err[],
-                        af_Environment *env) {
-    bool re = aFunGetSignal(signum);
-    if (!re)
-        return false;
-    int32_t *p_cfg = findEnvVarNumber(sigcfg, env);
-    int32_t cfg = 0;
-    if (p_cfg != nullptr)
-        cfg = *p_cfg;
-
-    if (cfg == 0) {  // 诱发错误
-        strncat(err, sigerr, 218);
-        setEnvVarNumber(sig, 0, env);
-    } else if (cfg == 1) {  // 设置环境变量
-        setEnvVarNumber(sig, 1, env);
-    } else  // 忽略
-        setEnvVarNumber(sig, 0, env);
-
-    writeDebugLog(aFunCoreLogger, "Get %s as cfg %d", sig, cfg);
-    return true;
-}
-
-/*
- * 函数名: checkRunGC
- * 目标: 检查是否该运行gc, 若是则返回true并运行gc, 否则返回false
- */
-static af_GuardianList *guardian_GC(char *type, bool is_guard, guardian_GC_data *data, af_Environment *env) {
-    time_t now = clock();
-    if ((now - data->last_time) < 1 * CLOCKS_PER_SEC)  // 间隔 1s 再执行
-        return nullptr;
-    data->last_time = now;
-
-    af_GuardianList *gl = gc_RunGC(env);
-    if (gl != nullptr)
-        writeDebugLog(aFunCoreLogger, "GC run destruct function");
-    return gl;
-}
-
-static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, af_Environment *env) {
-    char error_msg[218] = {NUL};
-    checkSignal(SIGINT, ev_sigint, ev_sigint_cfg, SIGNAL_INT, error_msg, env);
-    checkSignal(SIGTERM, ev_sigterm, ev_sigterm_cfg, SIGNAL_TERM, error_msg, env);
-#if (defined SIGUSR1 && defined SIGUSR2)
-    checkSignal(SIGUSR1, ev_sigu1, ev_sigu1_cfg, SIGNAL_U1, error_msg, env);
-    checkSignal(SIGUSR2, ev_sigu2, ev_sigu2_cfg, SIGNAL_U2, error_msg, env);
-#endif
-
-    if (*error_msg != NUL) {
-        // error_msg 有内容写入, 需要处理
-        if (env->activity->msg_down != nullptr) {
-            af_Message *msg;
-            if (EQ_STR("NORMAL", env->activity->msg_down->type)) {
-                msg = getFirstMessage(env);
-                gc_delObjectReference(*(af_Object **)msg->msg, env);
-                freeMessage(msg);
-            } else if (EQ_STR("ERROR", env->activity->msg_down->type)) {
-                msg = getFirstMessage(env);
-                freeErrorInfo(*(af_ErrorInfo **) msg->msg, env);
-                freeMessage(msg);
-            }
-        }
-
-        pushMessageDown(makeERRORMessage(SIGNAL_EXCEPTION, error_msg, env), env);
-    }
-    return nullptr;
-}
-
-
-af_Environment *creatAFunEnvironment(int argc, char **argv){
-    if (!aFunInit_mark)
-        return nullptr;
-
-    af_Environment *env = makeEnvironment(grt_always);
-    af_Code *code = nullptr;
-
-    for(int i = 0; i < argc; i++)
-        writeTrackLog(aFunCoreLogger, "[aFunlang] Env-arg %d. %s", i, argv[i]);
-
-    setArgc(argc, env);
-    for (int i = 0; i < argc; i++) {
-        char tmp[512] = {0};
-        snprintf(tmp, 512, ev_argvx_prefix "%d", i);
-        setEnvVarData(tmp, argv[i], env);
-    }
-
-    runtimeTool("base", &code, nullptr, env->protect, env);
-
-    if (code != nullptr) {
-        bool res = iterCode(code, 0, env);
-        freeAllCode(code);
-        if (!res) {
-            freeEnvironment(env);
-            return nullptr;
-        }
-    }
-
-    af_Object *cycle = makeCycleObject(env);  // gc 使用的函数
-    makeVarToProtectVarSpace(mg_sys_cycle, 3, 3, 3, cycle, env);
-    gc_delObjectReference(cycle, env);
-
-    enableEnvironment(env);
-    if (!env->is_derive) {  // 派生 gc 线程
-        setVarSpaceProtect(nullptr, env->protect, true);
-
-        af_Environment *gc_env = startRunThread(env, nullptr, nullptr, true, true, false, true, false);
-
-        /* 设置守护器 */
-        DLC_SYMBOL(GuardianFunc) func1 = MAKE_SYMBOL(guardian_Signal, GuardianFunc);
-        addGuardian("SIGNAL", false, false, 0, func1, nullptr, nullptr, gc_env);
-        FREE_SYMBOL(func1);
-
-        DLC_SYMBOL(GuardianFunc) func2 = MAKE_SYMBOL(guardian_GC, GuardianFunc);
-        addGuardian("GC", true, false, sizeof(guardian_GC_data),
-                    func2, nullptr, nullptr, gc_env);
-        FREE_SYMBOL(func2);
-
-        gc_env->status = core_normal;  // 手动启动env
-        af_Code *bt1 = makeElementCode(mg_sys_cycle, NUL, 1, "gc.aun.sys");
-        af_Code *bt2 = makeBlockCode(curly, bt1, NUL, 1, "gc.aun.sys", nullptr);
-        startRunThread_(gc_env, bt2, true);
-        env->gc_env = gc_env;
-    }
-
-    return env;
-}
-
-bool destructAFunEnvironment(af_Environment *env) {
-    waitForEnviromentExit(env);
-    return freeEnvironment(env);
-}
-
-static int runCode_(af_Parser *parser, int mode, FilePath save_path, af_Environment *env){
-    if (parser == nullptr)
-        return -1;
-
-    af_Code *bt_code = parserCode(parser);
-    freeParser(parser);
-    if (bt_code == nullptr)
-        return -2;
-
-    /* 写入文件 */
-    if (save_path != nullptr) {
-        int res = writeByteCode(bt_code, save_path);
-        if (res != 1) {
-            writeErrorLog(aFunCoreLogger, "Save %s bytecode error: %s", save_path, writeByteCodeError[res]);
-            printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_save_e, "Save aFun Bytecode file error"), save_path);
-        }
-    }
-
-    bool res = iterCode(bt_code, mode, env);
-    freeAllCode(bt_code);
-    if (!res)
-        return getCoreExitCode(env);
-    return 0;
-}
-
-
-/*
- * 函数名: runCodeFromString
- * 目标: 运行字符串中的程序 (源码形式)
- */
-int runCodeFromString(const char *code, const char *string_name, int mode, af_Environment *env){
-    if (env == nullptr || code == nullptr || !aFunInit_mark)
-        return -1;
-
-    if (string_name == nullptr)
-        string_name = "string-code.aun";
-
-    af_Parser *parser = makeParserByString(string_name, code, false);
-    return runCode_(parser, mode, nullptr, env);
-}
-
-/*
- * 函数名: runCodeFromFileSource
- * 目标: 运行文件中的程序 (源码形式)
- */
-int runCodeFromFileSource(FilePath file, bool save_afb, FilePath save_path, int mode, af_Environment *env){
-    if (env == nullptr || file == nullptr || !aFunInit_mark)
-        return -1;
-
-    char *sufix = getFileSurfix(file);
-    if (sufix == nullptr || !EQ_STR(".aun", sufix)) {
-        writeErrorLog(aFunCoreLogger, "Source is not .aun file: %s", (sufix == nullptr ? "" : sufix));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_source_not_aub_e, "Source is not .aun file"), (sufix == nullptr ? "" : sufix));
-        return -2;
-    }
-
-    /* 若文件不存在则自动生成 */
-    bool free_save_path = false;
-    if (save_afb && !save_path) {
-        char *path = getFileNameWithPath(file);
-        save_path = strJoin(path, ".aub", true, false);
-        free_save_path = true;
-    } else if (!save_afb)
-        save_path = nullptr;
-
-    af_Parser *parser = makeParserByFile(file);
-    int exit_code = runCode_(parser, mode, save_path, env);
-    if (free_save_path)
-        free(save_path);
-    return exit_code;
-}
-
-/*
- * 函数名: runCodeFromStdin
- * 目标: 运行stdin的程序 (源码形式)
- */
-int runCodeFromStdin(const char *name, af_Environment *env){
-    if (env == nullptr || CLEAR_STDIN() || !aFunInit_mark || !isatty(fileno(stdin)))  // ferror在feof前执行
-        return -1;
-
-    if (name == nullptr)
-        name = "sys-stdin.aun";
-
-    af_Parser *parser = makeParserByStdin(name);
-    return runCode_(parser, 0, nullptr, env);
-}
-
-/*
- * 函数名: runCodeFromMemory
- * 目标: 运行内存中的程序 (字节码形式)
- */
-int runCodeFromMemory(af_Code *code, int mode, af_Environment *env){
-    if (!aFunInit_mark)
-        return -1;
-
-    bool res = iterCode(code, mode, env);
-    if (!res)
-        return getCoreExitCode(env);
-    return 0;
-}
-
-/*
- * 函数名: runCodeFromFileByte
- * 目标: 运行文件中的程序 (字节码形式)
- */
-int runCodeFromFileByte(FilePath file, int mode, af_Environment *env){
-    if (env == nullptr || file == nullptr || !aFunInit_mark)
-        return -1;
-
-    char *sufix = getFileSurfix(file);
-    if (sufix == nullptr || !EQ_STR(".aub", sufix)) {
-        writeErrorLog(aFunCoreLogger, "Bytecode not .aub file: %s", (sufix == nullptr ? "" : sufix));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_bt_not_aub_e, "Bytecode not .aub file"), (sufix == nullptr ? "" : sufix));
-        return -2;
-    }
-
-    af_Code *code = nullptr;
-    int res = readByteCode(&code, file);
-    if(res != 1) {
-        writeErrorLog(aFunCoreLogger, "Load %s bytecode file error: %s", file, readByteCodeError[res]);
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_load_bt_e, "Load bytecode file error"), file);
-        return -2;
-    }
-
-    int exit_code = runCodeFromMemory(code, mode, env);
-    freeAllCode(code);
-    return exit_code;
-}
-
-/*
- * 函数名: runCodeFromFileByte
- * 目标: 运行文件中的程序 (字节码/源码形式)
- */
-int runCodeFromFile(FilePath file, bool save_afb, int mode, af_Environment *env){
-    if (env == nullptr || file == nullptr || !aFunInit_mark)
-        return -1;
-
-    char *sufix = getFileSurfix(file);
-    if (sufix != nullptr && !EQ_STR(".aun", sufix) && !EQ_STR(".aub", sufix)) {  // 不是源文件, 字节码文件或无后缀文件
-        writeErrorLog(aFunCoreLogger, "Run file not .aun/.aub file: %s", sufix);
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_file_aun_aub_e, "Run file not .aun/.aub file"), file);
-        return -2;
-    }
-
-    char *path = getFileNameWithPath(file);
-    char *path_1 = strJoin(path, ".aun", false, false);
-    char *path_2 = strJoin(path, ".aub", true, false);  // 此时释放path
-
-    time_t time_1 = getFileMTime(path_1);
-    time_t time_2 = getFileMTime(path_2);
-
-    if (time_1 == 0 && time_2 == 0) {
-        writeErrorLog(aFunCoreLogger, "Run file not exists: %s", file);
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_file_not_exists_e, "Run file not exists"), file);
-        free(path_1);
-        free(path_2);
-        return -3;
-    }
-
-    int exit_code;
-    if (time_2 >= time_1) {
-        exit_code = runCodeFromFileByte(path_2, mode, env);
-        if (exit_code != 0)
-            goto RUN_SOURCE_CODE;
-    } else {
-RUN_SOURCE_CODE:
-        exit_code = runCodeFromFileSource(path_1, save_afb, path_2, mode, env);
-    }
-
-    free(path_1);
-    free(path_2);
-    return exit_code;
-}
-
-/*
- * 函数名: buildFile
- * 目标: 生成字节码文件
- */
-int buildFile(FilePath out, FilePath in){
-    if (out == nullptr || in == nullptr || !aFunInit_mark)
-        return -1;
-
-    char *suffix_in = getFileSurfix(in);
-    char *suffix_out = getFileSurfix(out);
-    if (suffix_in == nullptr || !EQ_STR(".aun", suffix_in)) {  // 不是源文件
-        writeErrorLog(aFunCoreLogger, "Input not .aun %s", (suffix_in == nullptr ? "" : suffix_in));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(build_in_aun_e, "Input file is not .aun file"), (suffix_in == nullptr ? "" : suffix_in));
-        return -2;
-    }
-
-    if (suffix_out == nullptr || !EQ_STR(".aub", suffix_out)) {  // 不是字节码文件
-        writeErrorLog(aFunCoreLogger, "Output not .aub %s", (suffix_out == nullptr ? "" : suffix_out));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(build_out_aub_e, "Output file is not .aub file"), (suffix_out == nullptr ? "" : suffix_out));
-        return -2;
-    }
-
-    af_Parser *parser = makeParserByFile(in);
-    af_Code *code = parserCode(parser);
-    freeParser(parser);
-    if (code == nullptr)
-        return -2;
-
-    int res = writeByteCode(code, out);
-    freeAllCode(code);
-
-    if (res != 1) {
-        writeErrorLog(aFunCoreLogger, "Build %s error: %s", in, writeByteCodeError[res]);
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(build_error_e, "Build error"), in);
-        return -3;
-    }
-
-    return 0;
-}

src/runtime/base/__base.hpp

@@ -1,22 +0,0 @@
-#ifndef AFUN___BASE_HPP
-#define AFUN___BASE_HPP
-#include "__runtime.hpp"
-#include "__env.hpp"
-#include "__var.hpp"
-
-static const LiteralFuncList literal[] = {
-        /* 字符串匹配：\"[\s\S]*\" */
-        {.pattern="\\\"[\\s\\S]*\\\"", .func="str", .in_protect=true},
-        {.pattern=nullptr}
-};
-
-#define string_id "string"
-typedef struct ObjectString ObjectString;
-struct ObjectString{
-    char *str;
-};
-
-AFUN_LANG_NO_EXPORT void makeStrFunc(af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-AFUN_LANG_NO_EXPORT void makeQuitFunc(af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-
-#endif //AFUN___BASE_HPP

src/runtime/base/base.cpp

@@ -1,15 +0,0 @@
-#include "__base.hpp"
-
-int aFunTool_base(af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
-    writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base %p", vs);
-
-    makeLiteralRegexFromList(literal, env);
-    writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base literal success");
-
-    makeStrFunc(visitor, vs, env);
-    writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base str success");
-
-    makeQuitFunc(visitor, vs, env);
-    writeDebugLog(aFunCoreLogger, "Run runtimeTool-Base quit success");
-    return 0;
-}

src/runtime/base/quit.cpp

@@ -1,75 +0,0 @@
-#include <iostream>
-#include "__base.hpp"
-
-const std::string func_id = "quit-func";
-
-typedef struct QuitFunc QuitFunc;
-struct QuitFunc {
-    af_VarList *func_var_list;
-};
-
-static size_t funcGetSize(const std::string &id, af_Object *obj) {
-    return sizeof(QuitFunc);
-}
-
-static void funcInit(const std::string &id, af_Object *obj, QuitFunc *data, af_Environment *env) {
-    if (id != func_id)
-        return;
-    data->func_var_list = copyVarSpaceList(getRunVarSpaceList(env));
-}
-
-static bool funcArgCodeList(const std::string &id, af_Object *obj, af_ArgCodeList **acl, af_Code *code, void **mark, af_Environment *env) {
-    *acl = nullptr;
-    return true;
-}
-
-static bool funcArgList(const std::string &id, af_Object *obj, af_ArgList **al, af_ArgCodeList *acl, void *mark, af_Environment *env) {
-    *al = nullptr;
-    return true;
-}
-
-static bool funcVarList(const std::string &id, af_Object *obj, af_VarList **vsl, void *mark, af_Environment *env) {
-    auto sf = (QuitFunc *)getObjectData(obj);
-    *vsl = sf->func_var_list;
-    return true;
-}
-
-static af_FuncBody *funcBody(af_CallFuncInfo *cfi, af_Environment *env) {
-    setCoreExit(0, env);
-    pushMessageDown(makeNORMALMessage(getGlobal(env), env), env);
-    return nullptr;
-}
-
-static bool funcGetInfo(const std::string &id, af_Object *obj, af_FuncInfo **fi, af_Code *code, void *mark, af_Environment *env) {
-    *fi = makeFuncInfo(normal_scope, not_embedded, false, false, false);
-    DLC_SYMBOL(callFuncBody) func = MAKE_SYMBOL(funcBody, callFuncBody);
-    makeCFuncBodyToFuncInfo(func, nullptr, *fi);
-    FREE_SYMBOL(func);
-    return true;
-}
-
-static void funcDestruct(const std::string &id, af_Object *obj, QuitFunc *data, af_Environment *env) {
-    if (id == func_id)
-        freeAllVarSpaceList(data->func_var_list);
-}
-
-void makeQuitFunc(af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
-    static APIFuncList api_list[] = {
-            {.name="obj_getDataSize", .func=(void *)funcGetSize, .dlc=nullptr},
-            {.name="obj_initData", .func=(void *)funcInit, .dlc=nullptr},
-            {.name="obj_destructData", .func=(void *)funcDestruct, .dlc=nullptr},
-            {.name="obj_funcGetArgCodeList", .func=(void *)funcArgCodeList, .dlc=nullptr},
-            {.name="obj_funcGetVarList", .func=(void *)funcVarList, .dlc=nullptr},
-            {.name="obj_funcGetArgList", .func=(void *)funcArgList, .dlc=nullptr},
-            {.name="obj_funcGetInfo", .func=(void *)funcGetInfo, .dlc=nullptr},
-            {.name=nullptr}
-    };
-
-    static ObjectDefineList obj_def[] = {
-            {.id=func_id, .free_api=true, .api_list=api_list, .allow_inherit=false,
-                    .var_name="quit", .p_self=3, .p_posterity=3, .p_external=3},
-            {.id=""}
-    };
-
-    makeObjectFromList(obj_def, visitor, vs, env);
-}

src/runtime/base/str_obj.cpp

@@ -1,120 +0,0 @@
-#include "__base.hpp"
-
-static const std::string string_func_id = "string-maker";
-typedef struct ObjectStrFunc ObjectStrFunc;
-struct ObjectStrFunc {
-    af_ObjectAPI *api;
-    af_VarSpace *share_vs;
-    af_VarList *func_var_list;
-};
-
-static size_t strGetSize(const std::string &id, af_Object *obj) {
-    return sizeof(ObjectString);
-}
-
-static void strInit(const std::string &id, af_Object *obj, ObjectString *data, af_Environment *env) {
-    if (id == string_id)
-        data->str = nullptr;
-}
-
-static void strDestruct(const std::string &id, af_Object *obj, ObjectString *data, af_Environment *env) {
-    if (id == string_id) {
-        free(data->str);
-    }
-}
-
-static void strLiteral(const std::string &id, af_Object *obj, ObjectString *data, char *str, af_Environment *env) {
-    if (id != string_id || data->str != nullptr)
-        return;
-    writeTrackLog(aFunCoreLogger, "strLiteral str = %s, %d", str, strlen(str));
-    data->str = NEW_STR(STR_LEN(str) - 2);  // 取出两个引号
-    memcpy(data->str, str + 1, (STR_LEN(str) - 2) * sizeof(char));
-}
-
-static size_t strFuncGetSize(const std::string &id, af_Object *obj) {
-    return sizeof(ObjectStrFunc);
-}
-
-static void strFuncInit(const std::string &id, af_Object *obj, ObjectStrFunc *data, af_Environment *env) {
-    static const APIFuncList api_list[] = {
-            {.name="obj_getDataSize", .func=(void *)strGetSize, .dlc=nullptr},
-            {.name="obj_initData", .func=(void *)strInit, .dlc=nullptr},
-            {.name="obj_destructData", .func=(void *)strDestruct, .dlc=nullptr},
-            {.name="obj_literalSetting", .func=(void *)strLiteral, .dlc=nullptr},
-            {.name=nullptr}
-    };
-
-    if (id != string_func_id)
-        return;
-    data->func_var_list = copyVarSpaceList(getRunVarSpaceList(env));
-    data->share_vs = makeVarSpace(obj, 3, 2, 0, env);
-    data->api = makeAPIFromList(api_list);
-    gc_delVarSpaceReference(data->share_vs, env);
-}
-
-static bool strFuncArgCodeList(const std::string &id, af_Object *obj, af_ArgCodeList **acl, af_Code *code, void **mark, af_Environment *env) {
-    *acl = nullptr;
-    return true;
-}
-
-static bool strFuncArgList(const std::string &id, af_Object *obj, af_ArgList **al, af_ArgCodeList *acl, void *mark, af_Environment *env) {
-    *al = nullptr;
-    return true;
-}
-
-static bool strFuncVarList(const std::string &id, af_Object *obj, af_VarList **vsl, void *mark, af_Environment *env) {
-    auto sf = (ObjectStrFunc *)getObjectData(obj);
-    *vsl = sf->func_var_list;
-    return true;
-}
-
-static af_FuncBody *strFuncBody(af_CallFuncInfo *cfi, af_Environment *env) {
-    af_Object *obj = cfi->func;
-    auto *osf = (ObjectStrFunc *)getObjectData(obj);
-    af_Object *str = makeObject((char *) string_id, false, osf->api, false, nullptr, true, makeInherit(obj), env);
-    pushMessageDown(makeNORMALMessage(str, env), env);
-    return nullptr;
-}
-
-static bool strFuncGetInfo(const std::string &id, af_Object *obj, af_FuncInfo **fi, af_Code *code, void *mark, af_Environment *env) {
-    *fi = makeFuncInfo(normal_scope, not_embedded, false, false, false);
-    DLC_SYMBOL(callFuncBody) func = MAKE_SYMBOL(strFuncBody, callFuncBody);
-    makeCFuncBodyToFuncInfo(func, nullptr, *fi);
-    FREE_SYMBOL(func);
-    return true;
-}
-
-static af_GcList *strFuncGetGc(const std::string &id, af_Object *obj, ObjectStrFunc *data) {
-    af_GcList *gl = pushGcList(glt_vsl, data->func_var_list, nullptr);
-    gl = pushGcList(glt_vs, data->share_vs, gl);
-    return gl;
-}
-
-static void strFuncDestruct(const std::string &id, af_Object *obj, ObjectStrFunc *data, af_Environment *env) {
-    if (id == string_func_id) {
-        freeObjectAPI(data->api);
-        freeAllVarSpaceList(data->func_var_list);
-    }
-}
-
-void makeStrFunc(af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
-    static APIFuncList api_list[] = {
-            {.name="obj_getDataSize", .func=(void *)strFuncGetSize, .dlc=nullptr},
-            {.name="obj_initData", .func=(void *)strFuncInit, .dlc=nullptr},
-            {.name="obj_destructData", .func=(void *)strFuncDestruct, .dlc=nullptr},
-            {.name="obj_funcGetArgCodeList", .func=(void *)strFuncArgCodeList, .dlc=nullptr},
-            {.name="obj_funcGetVarList", .func=(void *)strFuncVarList, .dlc=nullptr},
-            {.name="obj_funcGetArgList", .func=(void *)strFuncArgList, .dlc=nullptr},
-            {.name="obj_funcGetInfo", .func=(void *)strFuncGetInfo, .dlc=nullptr},
-            {.name="obj_getGcList", .func=(void *)strFuncGetGc, .dlc=nullptr},
-            {.name=nullptr}
-    };
-
-    static ObjectDefineList obj_def[] = {
-            {.id=string_func_id, .free_api=true, .api_list=api_list, .allow_inherit=true,
-                    .var_name="str", .p_self=3, .p_posterity=3, .p_external=3},
-            {.id=""}
-    };
-
-    makeObjectFromList(obj_def, visitor, vs, env);
-}

src/runtime/cycle_obj.cpp

@@ -1,106 +0,0 @@
-#include "aFunlang.hpp"
-#include "__cycle_obj.hpp"
-
-size_t getSizec_Cycle(const std::string &id, af_Object *obj) {
-    return sizeof(af_VarList *);
-}
-
-void initDatac_Cycle(const std::string &id, af_Object *obj, af_VarList **data, af_Environment *env) {
-    *data = pushProtectVarList(nullptr, env);
-}
-
-void freeDatac_Cycle(const std::string &id, af_Object *obj, af_VarList **data, af_Environment *env) {
-    freeAllVarSpaceList(*data);
-}
-
-typedef struct CycleMark CycleMark;
-struct CycleMark {
-    af_FuncInfo *fi;
-    af_FuncBody *body;
-};
-
-af_FuncBody *func_Cycle(af_CallFuncInfo *cfi, af_Environment *env) {  // 测试用函数
-    auto mark = (CycleMark *)cfi->mark;
-    cfi->body_next = mark->body;
-    pushMessageDown(makeNORMALMessage(getGlobal(env), env), env);
-    return nullptr;
-}
-
-bool getInfoc_Cycle(const std::string &id, af_Object *obj, af_FuncInfo **fi, af_Code *code, CycleMark *mark, af_Environment *env) {
-    mark->fi = makeFuncInfo(normal_scope, not_embedded, false, false, false);
-    *fi = mark->fi;
-
-    DLC_SYMBOL(callFuncBody) func = MAKE_SYMBOL(func_Cycle, callFuncBody);
-    mark->body = makeCFuncBodyToFuncInfo(func, nullptr, mark->fi);  // 压入两个相同的 body
-    FREE_SYMBOL(func);
-
-    return true;
-}
-
-bool getAclc_Cycle(const std::string &id, af_Object *obj, af_ArgCodeList **acl, af_Code *code, CycleMark **mark, af_Environment *env) {
-    *acl = nullptr;
-    *mark = calloc(1, CycleMark);
-    return true;
-}
-
-bool getVslc_Cycle(const std::string &id, af_Object *obj, af_VarList **vsl, CycleMark *mark, af_Environment *env) {
-    *vsl = *(af_VarList **)getObjectData(obj);
-    return true;
-}
-
-af_GcList *getGcListc_Cycle(const std::string &id, af_Object *obj, void *data) {
-    af_GcList *gl = pushGcList(glt_vsl, *(af_VarList **)data, nullptr);
-    return gl;
-}
-
-bool getAlc_Cycle(const std::string &id, af_Object *obj, af_ArgList **al, af_ArgCodeList *acl, CycleMark *mark, af_Environment *env) {
-    *al = nullptr;
-    return true;
-}
-
-void freeMarkc_Cycle(const std::string &id, af_Object *obj, CycleMark *mark) {
-    free(mark);
-}
-
-af_Object *makeCycleObject(af_Environment *env) {
-    af_ObjectAPI *api = makeObjectAPI();
-    DLC_SYMBOL(objectAPIFunc) get_alc = MAKE_SYMBOL(getAclc_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) get_vsl = MAKE_SYMBOL(getVslc_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) get_al = MAKE_SYMBOL(getAlc_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) get_info = MAKE_SYMBOL(getInfoc_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) free_mark = MAKE_SYMBOL(freeMarkc_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) get_gl = MAKE_SYMBOL(getGcListc_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) get_size = MAKE_SYMBOL(getSizec_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) init_data = MAKE_SYMBOL(initDatac_Cycle, objectAPIFunc);
-    DLC_SYMBOL(objectAPIFunc) free_data = MAKE_SYMBOL(freeDatac_Cycle, objectAPIFunc);
-    if (addAPI(get_size, "obj_getDataSize", api) != 1)
-        return nullptr;
-    if (addAPI(init_data, "obj_initData", api) != 1)
-        return nullptr;
-    if (addAPI(free_data, "obj_destructData", api) != 1)
-        return nullptr;
-    if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-        return nullptr;
-    if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-        return nullptr;
-    if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-        return nullptr;
-    if (addAPI(get_info, "obj_funcGetInfo", api) != 1)
-        return nullptr;
-    if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-        return nullptr;
-    if (addAPI(get_gl, "obj_getGcList", api) != 1)
-        return nullptr;
-
-    FREE_SYMBOL(get_alc);
-    FREE_SYMBOL(get_vsl);
-    FREE_SYMBOL(get_al);
-    FREE_SYMBOL(get_info);
-    FREE_SYMBOL(free_mark);
-    FREE_SYMBOL(get_gl);
-    FREE_SYMBOL(get_size);
-    FREE_SYMBOL(init_data);
-    FREE_SYMBOL(free_data);
-
-    return makeObject("func", true, api, true, nullptr, true, nullptr, env);
-}

src/runtime/runtime.cpp

@@ -1,209 +0,0 @@
-#include "__runtime.hpp"
-#include "__global_obj.hpp"
-#include "runtime_tool.hpp"
-
-/* 数组为只读的内容 */
-static const ToolFunc global_tool_list[] = {
-        {.name="base", .func=aFunTool_base},
-        {.name=nullptr, .func=nullptr},
-};
-
-/**
- * runtimeTool
- * 目标: 调用指定内置包(tool)
- * 返回 (0)   执行正常
- * 返回 (1)  库不存在
- * 必须保证 vs 有被 gc 引用
- */
-int runtimeTool(const char *name, af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
-    if (name == nullptr || code == nullptr || env == nullptr || vs == nullptr)
-        return 1;
-    *code = nullptr;
-    for (const ToolFunc *tf = global_tool_list; global_tool_list->name != nullptr; tf++) {
-        if (EQ_STR(tf->name, name)) {
-            int exit_code = tf->func(code, visitor, vs, env);
-            if (exit_code == 1)  // 将 exit_code 映射到0
-                return 0;
-            return exit_code;
-        }
-    }
-    return 1;
-}
-
-/*
- * 函数名: runtimeToolImport
- * 目标: 生成vs, 调用指定内置包(tool)
- */
-int runtimeToolImport(const char *name, af_Object **obj, af_Code **code, af_Environment *env) {
-    if (name == nullptr || code == nullptr || env == nullptr || obj == nullptr)
-        return 1;
-    *obj = makeGlobalObject(env);  // 保留 gc 引用
-    return runtimeTool(name, code, *obj, getObjectVarSpace((*obj)), env);
-}
-
-/*
- * 函数名: makeAPIFromList
- * 目标: 根据APIFuncList生成api表并写入数据
- */
-af_ObjectAPI *makeAPIFromList(const APIFuncList api_list[]) {
-    af_ObjectAPI *api = makeObjectAPI();
-
-    for (const APIFuncList *af = api_list; af->name != nullptr; af++) {
-        if (af->func != nullptr) {
-            DLC_SYMBOL(objectAPIFunc) func = MAKE_SYMBOL_FROM_HANDLE(af->func, af->dlc, objectAPIFunc);
-            addAPI(func, af->name, api);
-            FREE_SYMBOL(func);
-            continue;
-        } else if (af->func_ == nullptr)
-            continue;  // 遇到错误
-
-        addAPI(af->func_, af->name, api);
-        if (af->free_func_)
-            FREE_SYMBOL(af->func_);
-    }
-
-    return api;
-}
-
-/**
- * 根据ObjectDefineList生成Object, 并保存到对应位置和变量空间中
- * 必须保证 VarSpace 有被 gc 引用
- */
-void makeObjectFromList(const ObjectDefineList obj_def[], af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
-    for (const ObjectDefineList *od = obj_def; od->id.size() != 0; od++) {
-        af_ObjectAPI *api = od->api;
-        if (api == nullptr)
-            api = makeAPIFromList(od->api_list);
-
-        af_Object *obj = makeObject(od->id, od->free_api, api, od->allow_inherit, od->belong, true, od->inherit, env);
-        if (vs != nullptr && od->var_name != nullptr) {
-            if (!makeVarToVarSpace(od->var_name, od->p_self, od->p_posterity, od->p_external, obj, vs, visitor, env))
-                setVarToVarSpace(od->var_name, obj, visitor, vs);  // 若失败则尝试直接设定变量
-        }
-
-        if (od->save != nullptr)
-            *(od->save) = obj;
-        else
-            gc_delObjectReference(obj, env);
-    }
-}
-
-/*
- * 函数名: makeLiteralRegexFromList
- * 目标: 根据LiteralFuncList压入新的字面量处理器
- */
-void makeLiteralRegexFromList(const LiteralFuncList literal_list[], af_Environment *env) {
-    for (const LiteralFuncList *lt = literal_list; lt->pattern != nullptr; lt++)
-        pushLiteralRegex(lt->pattern, lt->func, lt->in_protect, env);
-}
-
-/*
- * 函数名: makeTopMsgProcessFromList
- * 目标: 根据TopMsgFuncList压入新的字面量处理器
- */
-void makeTopMsgProcessFromList(const TopMsgFuncList top_msg_list[], af_Environment *env) {
-    for (const TopMsgFuncList *tml = top_msg_list; tml->type != nullptr; tml++) {
-        if (tml->func != nullptr) {
-            DLC_SYMBOL(TopMsgProcessFunc) func = MAKE_SYMBOL_FROM_HANDLE(tml->func, tml->dlc, TopMsgProcessFunc);
-            addTopMsgProcess(tml->type, func, env);
-            FREE_SYMBOL(func);
-            continue;
-        } else if (tml->func_ == nullptr)
-            continue;  // 遇到错误
-
-        addTopMsgProcess(tml->type, tml->func_, env);
-        if (tml->free_func_)
-            FREE_SYMBOL(tml->func_);
-    }
-}
-
-/*
- * 函数名: makeInheritFromListReverse
- * 目标: 以InheritDefineList的顺序反向压入Inherit
- * 注意: pushInherit是反向压入, 因此InheritDefine得正向读取, 最后Inherit反向压入
- */
-static af_Inherit *makeInheritFromListReverse(const InheritDefineList inherit_list[]) {
-    af_Inherit *inherit = nullptr;
-    af_Inherit **pinherit = &inherit;
-    for (const InheritDefineList *ind = inherit_list; ind->obj != nullptr; ind++) {
-        af_Inherit *ih = makeInherit(ind->obj);
-        pinherit = pushInherit(pinherit, ih);
-    }
-
-    return inherit;
-}
-
-/*
- * 函数名: makeInheritFromListForward
- * 目标: 以InheritDefineList的顺序压入Inherit
- * 注意: pushInherit是反向压入, 因此InheritDefine也得反向读取, 最后Inherit正向压入
- */
-static af_Inherit *makeInheritFromListForward(const InheritDefineList inherit_list[]) {
-    af_Inherit *inherit = nullptr;
-    af_Inherit **pinherit = &inherit;
-    const InheritDefineList *ind = inherit_list;
-
-    /* 找到最后一个元素 */
-    while (ind->obj != nullptr)
-        ind++;
-    ind--;  // 最后一个元素的前一个元素为最后一个有效元素
-
-    for(NULL; ind != inherit_list; ind++) {
-        af_Inherit *ih = makeInherit(ind->obj);
-        pinherit = pushInherit(pinherit, ih);
-    }
-
-    return inherit;
-}
-
-/*
- * 函数名: makeInheritFromList
- * 目标: 根据InheritDefineList生成新的Inherit
- */
-af_Inherit *makeInheritFromList(const InheritDefineList inherit_list[], bool is_reverse) {
-    if (is_reverse)
-        return makeInheritFromListReverse(inherit_list);
-    else
-        return makeInheritFromListForward(inherit_list);
-}
-
-/*
- * 函数名: makeGuardianFromList
- * 目标: 根据GuardianFuncList压入新的字面量处理器
- */
-void makeGuardianFromList(const GuardianFuncList gd_list[], af_Environment *env) {
-    for (const GuardianFuncList *gdl = gd_list; gdl->type != nullptr; gdl++) {
-        DLC_SYMBOL(GuardianFunc) func = gdl->func_;
-        bool free_func_ = gdl->free_func_;
-
-        DLC_SYMBOL(GuardianDestruct) destruct = gdl->destruct_;
-        bool free_destruct_ = gdl->free_destruct_;
-
-        if (func == nullptr) {
-            if (gdl->func == nullptr)
-                continue;  // 遇到错误
-            func = MAKE_SYMBOL_FROM_HANDLE(gdl->func, gdl->dlc, GuardianFunc);
-            free_func_ = true;
-        }
-
-        if (destruct == nullptr) {
-            if (gdl->destruct == nullptr)
-                continue;  // 遇到错误
-            destruct = MAKE_SYMBOL_FROM_HANDLE(gdl->destruct, gdl->dlc, GuardianDestruct);
-            free_destruct_ = true;
-        }
-
-        void *tmp = nullptr;
-        void **pdata = gdl->data;
-        if (pdata == nullptr)
-            pdata = &tmp;
-
-        if (addGuardian(gdl->type, gdl->always, gdl->derive, gdl->size, func, destruct, pdata, env))
-            gdl->initData(*pdata, env);
-
-        if (free_func_)
-            FREE_SYMBOL(func);
-        if (free_destruct_)
-            FREE_SYMBOL(destruct);
-    }
-}

src/runtime/runtime_tool.hpp

@@ -1,6 +0,0 @@
-#ifndef AFUN_RUNTIME_TOOL_HPP
-#define AFUN_RUNTIME_TOOL_HPP
-
-AFUN_LANG_NO_EXPORT int aFunTool_base(af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-
-#endif //AFUN_RUNTIME_TOOL_HPP

src/tool/__regex.hpp

@@ -1,10 +0,0 @@
-#ifndef TOOL_REGEX_H_
-#define TOOL_REGEX_H_
-#include "regex.hpp"
-
-struct af_Regex {
-    pcre2_code *re;  // 正则表达式
-    char *pattern;  // 正则表达式的字符串
-};
-
-#endif //TOOL_REGEX_H_

src/tool/byte.cpp

@@ -1,16 +1,19 @@
 #include <cinttypes>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include "tool.hpp"
+using namespace aFuntool;
 
-enum af_EndianType endian = little_endian;
-enum af_EndianType save_as = little_endian;  // 默认以小端序存储
+namespace aFuntool {
+    enum af_EndianType endian = little_endian;
+    enum af_EndianType save_as = little_endian;  // 默认以小端序存储
+}
 
-/*
- * 函数名: getEndian
- * 目标: 获取机器字节序
+/**
+ * 获取机器字节序
  */
-void getEndian() {
+void aFuntool::getEndian() {
     union {
         int16_t a;//元素a，占2个字节
         int8_t b;//元素b，占1个字节，b在内存中的地址为a最低字节的地址
@@ -24,138 +27,118 @@ void getEndian() {
         abort();
 }
 
-bool byteWriteUint_8(FILE *file, uint8_t ch) {
-    return fwrite(&ch, sizeof(uint8_t), 1, file) == 1;
-}
-
-bool byteWriteUint_16(FILE *file, uint16_t num) {
-    if (endian != save_as) {
-        union {
-            uint16_t a;//元素a，占2个字节
-            uint8_t b[2];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
-        } in {.a = num}, out {};
-
-        out.b[1] = in.b[0];
-        out.b[0] = in.b[1];
-        num = out.a;
-    }
-
-    return fwrite(&num, sizeof(uint16_t), 1, file) == 1;
-}
-
-bool byteWriteUint_32(FILE *file, uint32_t num) {
-    if (endian != save_as) {
-        union {
-            uint32_t a;//元素a，占2个字节
-            uint8_t b[4];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
-        } in {.a = num}, out {};
-
-        out.b[3] = in.b[0];
-        out.b[2] = in.b[1];
-        out.b[1] = in.b[2];
-        out.b[0] = in.b[3];
-        num = out.a;
-    }
-
-    return fwrite(&num, sizeof(uint32_t), 1, file) == 1;
-}
-
-bool byteWriteUint_64(FILE *file, uint64_t num) {
+/**
+ * 写入一个整数
+ * @tparam T 整数类型
+ * @param file FILE 结构体
+ * @param num 整数
+ * @return
+ */
+template <typename T>
+bool aFuntool::byteWriteInt(FILE *file, T num) {
     if (endian != save_as) {
+        const size_t len = sizeof(T) / sizeof(uint8_t);
         union {
-            uint64_t a;//元素a，占2个字节
-            uint8_t b[8];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
+            T a;//元素a，占2个字节
+            uint8_t b[len];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
         } in {.a = num}, out {};
 
-        out.b[7] = in.b[0];
-        out.b[6] = in.b[1];
-        out.b[5] = in.b[2];
-        out.b[4] = in.b[3];
-        out.b[3] = in.b[4];
-        out.b[2] = in.b[5];
-        out.b[1] = in.b[6];
-        out.b[0] = in.b[7];
+        for (int i = 0; i < len; i++)
+            out.b[len - i] = in.b[i];  // 大小端序转换
         num = out.a;
     }
 
-    return fwrite(&num, sizeof(uint64_t), 1, file) == 1;
-}
-
-bool byteReadUint_8(FILE *file, uint8_t *ch) {
-    return fread(ch, sizeof(uint8_t), 1, file) == 1;
+    return fwrite(&num, sizeof(T), 1, file) == 1;
 }
 
-bool byteReadUint_16(FILE *file, uint16_t *num) {
-    size_t re = fread(num, sizeof(uint16_t), 1, file);
+/**
+ * 读取一个整数
+ * @tparam T 整数类型
+ * @param file FILE 结构体
+ * @param num 整数
+ * @return
+ */
+template <typename T>
+bool aFuntool::byteReadInt(FILE *file, T *num) {
+    size_t re = fread(num, sizeof(T), 1, file);
 
     if (endian != save_as) {
+        const size_t len = sizeof(T) / sizeof(uint8_t);
         union {
-            uint16_t a;//元素a，占2个字节
-            uint8_t b[2];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
+            T a;//元素a，占2个字节
+            uint8_t b[len];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
         } in {.a = *num}, out {};
 
-        out.b[1] = in.b[0];
-        out.b[0] = in.b[1];
+        for (int i = 0; i < len; i++)
+            out.b[len - i] = in.b[i];  // 大小端序转换
         *num = out.a;
     }
 
     return re == 1;
 }
 
-bool byteReadUint_32(FILE *file, uint32_t *num) {
-    size_t re = fread(num, sizeof(uint32_t), 1, file);
-
-    if (endian != save_as) {
-        union {
-            uint32_t a;//元素a，占2个字节
-            uint8_t b[4];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
-        } in {.a = *num}, out {};
-
-        out.b[3] = in.b[0];
-        out.b[2] = in.b[1];
-        out.b[1] = in.b[2];
-        out.b[0] = in.b[3];
-        *num = out.a;
-    }
-
-    return re == 1;
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, int8_t num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, int16_t num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, int32_t num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, int64_t num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, uint8_t num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, uint16_t num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, uint32_t num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteWriteInt(FILE *file, uint64_t num);
+
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt<int8_t>(FILE *file, int8_t *num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt(FILE *file, int16_t *num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt(FILE *file, int32_t *num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt(FILE *file, int64_t *num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt(FILE *file, uint8_t *num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt(FILE *file, uint16_t *num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt(FILE *file, uint32_t *num);
+template AFUN_TOOL_EXPORT bool aFuntool::byteReadInt(FILE *file, uint64_t *num);
+
+/**
+ * 写入一个C风格字符串
+ */
+bool aFuntool::byteWriteStr(FILE *file, const char *str) {
+    if (!byteWriteInt<uint16_t>(file, (uint16_t)strlen(str)))
+        return false;
+    return fwrite(str, sizeof(char), strlen(str), file) == strlen(str);
 }
 
-bool byteReadUint_64(FILE *file, uint64_t *num) {
-    size_t re = fread(num, sizeof(uint64_t), 1, file);
-
-    if (endian != save_as) {
-        union {
-            uint64_t a;//元素a，占2个字节
-            uint8_t b[8];//元素b，占1个字节，b在内存中的地址为a最低字节的地址
-        } in {.a = *num}, out {};
 
-        out.b[7] = in.b[0];
-        out.b[6] = in.b[1];
-        out.b[5] = in.b[2];
-        out.b[4] = in.b[3];
-        out.b[3] = in.b[4];
-        out.b[2] = in.b[5];
-        out.b[1] = in.b[6];
-        out.b[0] = in.b[7];
-        *num = out.a;
-    }
-
-    return re == 1;
+/**
+ * 写入一个C++风格字符串
+ */
+bool aFuntool::byteWriteStr(FILE *file, const std::string &str) {
+    size_t size = str.size();
+    if (!byteWriteInt<uint16_t>(file, (uint16_t)size))
+        return false;
+    return fwrite(str.c_str(), sizeof(char), size, file) == size;
 }
 
-bool byteWriteStr(FILE *file, const char *str) {
-    if (!byteWriteUint_16(file, strlen(str)))
+
+/**
+ * 读取一个C风格字符串
+ */
+bool aFuntool::byteReadStr(FILE *file, char *&str) {
+    uint16_t len;
+    if (!byteReadInt<uint16_t>(file, &len))
         return false;
-    return fwrite(str, sizeof(char), strlen(str), file) == strlen(str);
+
+    str = calloc(len + 1, char);
+    return fread(str, sizeof(char), len, file) == len;
 }
 
-bool byteReadStr(FILE *file, char **str) {
+/**
+ * 读取一个C++风格字符串
+ */
+bool aFuntool::byteReadStr(FILE *file, std::string &str) {
     uint16_t len;
-    if (!byteReadUint_16(file, &len))
+    if (!byteReadInt<uint16_t>(file, &len))
         return false;
 
-    *str = calloc(len + 1, char);
-    return fread(*str, sizeof(char), len, file) == len;
+    char *tmp = calloc(len + 1, char);
+    size_t ret = fread(tmp, sizeof(char), len, file);
+    str = tmp;
+    free(tmp);
+    return ret == len;
 }
-

src/tool/dlc.cpp

@@ -1,30 +1,18 @@
 #include "tool.hpp"
-
-#ifndef GC_SZIE
-#define GC_SZIE (0)
-#endif
-
-static bool freeLibary_(struct DlcHandle *dlc);
-
-struct DlcSymbol_ {
-    void *symbol;
-    struct DlcHandle *dlc;
-};
-
-struct DlcHandle {
-    void *handle;
-    long long int link;  // 引用计数
-    long long int count;  // 开启计数
-    struct DlcHandle *next;
-    struct DlcHandle *last;
-};
-
-static struct DlcHandle *dlc_l = nullptr;
-static int gc_count = 0;
-
-struct DlcHandle *openLibary(const char *file, int mode) {
+#include "dlc.hpp"
+using namespace aFuntool;
+
+static DlcHandle *dlc_l = nullptr;
+
+/**
+ * 打开动态库
+ * @param file 动态库路径
+ * @param mode 模式
+ * @return
+ */
+DlcHandle *aFuntool::openLibrary(const char *file, int mode) {
     void *handle = dlopen(file, mode);
-    struct DlcHandle *dlc;
+    DlcHandle *dlc;
 
     if (handle == nullptr)
         return nullptr;
@@ -32,124 +20,65 @@ struct DlcHandle *openLibary(const char *file, int mode) {
     for (struct DlcHandle *tmp = dlc_l; tmp != nullptr; tmp = tmp->next) {
         if (tmp->handle == handle) {
             dlclose(handle);  // 减少dlopen时对handle的引用计数
-            tmp->count++;
+            tmp++;
             return tmp;
         }
     }
 
-    dlc = calloc(1, struct DlcHandle);
-    dlc->handle = handle;
+    dlc = new DlcHandle(handle);
 
-    dlc->count = 1;
     dlc->next = dlc_l;
-    dlc->last = nullptr;
+    dlc->prev = nullptr;
     if (dlc_l != nullptr)
-        dlc_l->last = dlc;
+        dlc_l->prev = dlc;
     dlc_l = dlc;
 
     return dlc;
 }
 
-bool freeLibary(struct DlcHandle *dlc) {
-    if (dlc->count == 0)
-        return false;
-    dlc->count--;
-    return true;
+aFuntool::DlcHandle::DlcHandle(void *handle){
+    this->handle = handle;
+    this->link = 1;
+    this->next = nullptr;
+    this->prev = nullptr;
 }
 
-static bool freeLibary_(struct DlcHandle *dlc){
-    if (dlc->link != 0)  // f - 强制释放
-        return false;
-
-    dlclose(dlc->handle);
 
-    if (dlc->last == nullptr)
-        dlc_l = dlc->next;
-    else
-        dlc->last->next = dlc->next;
-
-    if (dlc->next != nullptr)
-        dlc->next->last = dlc->last;
-
-    free(dlc);
-    return true;
-}
+aFuntool::DlcHandle::~DlcHandle() {
+    dlclose(handle);
 
-static bool freeLibary_Exit(struct DlcHandle *dlc) {
-    if (dlc->last == nullptr)
-        dlc_l = dlc->next;
+    if (prev == nullptr)
+        dlc_l = next;
     else
-        dlc->last->next = dlc->next;
-
-    /* atexit函数中不使用dlclose */
-
-    if (dlc->next != nullptr)
-        dlc->next->last = dlc->last;
+        prev->next = next;
 
-    free(dlc);
-    return true;
+    if (next != nullptr)
+        next->prev = prev;
 }
 
-static void blindSymbol(struct DlcSymbol_ *ds, struct DlcHandle *dlc) {
-    if (ds->dlc != nullptr)
-        ds->dlc->link--;
 
-    ds->dlc = dlc;
-    dlc->link++;
+void aFuntool::DlcHandle::close() {
+    this->operator--(1);
 }
 
-struct DlcSymbol_ *makeSymbol_(DlcHandle *dlc, void *symbol) {
-    auto ds = calloc(1, struct DlcSymbol_);
-    ds->symbol = symbol;
 
-    if (dlc != nullptr)
-        blindSymbol(ds, dlc);
-    return ds;
+int aFuntool::DlcHandle::operator++(int){
+    return link++;
 }
 
-struct DlcSymbol_ *copySymbol_(struct DlcSymbol_ *ds) {
-    if (ds == nullptr)
-        return nullptr;
-
-    auto new_symbol = calloc(1, struct DlcSymbol_);
-    new_symbol->symbol = ds->symbol;
-    if (ds->dlc != nullptr)
-        blindSymbol(new_symbol, ds->dlc);
-    return new_symbol;
-}
-
-struct DlcSymbol_ *getSymbol_(struct DlcHandle *dlc, const char *name) {
-    void *symbol = dlsym(dlc->handle, name);
-    if (symbol == nullptr)
-        return nullptr;
-
-    auto ds = calloc(1, struct DlcSymbol_);
-    ds->symbol = symbol;
-    blindSymbol(ds, dlc);
-    return ds;
-}
-
-void dlcGC() {
-    for (struct DlcHandle *tmp = dlc_l, *next; tmp != nullptr; tmp = next) {
-        next = tmp->next;
-        if (tmp->link == 0 && tmp->count == 0)
-            freeLibary_(tmp);
-    }
-}
-
-void freeSymbol_(struct DlcSymbol_ *symbol) {
-    if (symbol->dlc != nullptr) {
-        symbol->dlc->link--;
-        gc_count++;
-    }
-
-    free(symbol);
 
-    if (gc_count >= GC_SZIE)
-        dlcGC();
+int aFuntool::DlcHandle::operator--(int){
+    int ret = link--;
+    if (link == 0)
+        delete this;  // 删除自己
+    return ret;
 }
 
-void dlcExit() {
+/**
+ * 退出函数
+ * 需要使用at_exit注册
+ */
+void aFuntool::dlcExit() {
     while (dlc_l != nullptr) {
         auto next = dlc_l->next;
         free(dlc_l);

src/tool/exit_.cpp

@@ -1,28 +1,35 @@
 #include "tool.hpp"
 #include "pthread.h"
+using namespace aFuntool;
 
-#define EXIT_FUNC_SIZE (1024)
-
+static const int exit_func_size = 1024;
 static pthread_mutex_t exit_mutex = PTHREAD_MUTEX_INITIALIZER;
 struct ExitFuncData {
     aFunExitFunc *func;
     void *data;
-} exit_func[EXIT_FUNC_SIZE];
+} exit_func[exit_func_size];
 
-[[ noreturn ]] void aFunExit(int exit_code) {
+/**
+ * 退出程序
+ * @param exit_code 退出代码
+ */
+[[ noreturn ]] void aFuntool::aFunExit(int exit_code) {
     if (pthread_mutex_trylock(&exit_mutex) == 0) {
         int count = 0;
-        for (struct ExitFuncData *tmp = exit_func; tmp->func != nullptr && count < EXIT_FUNC_SIZE; tmp++, count++)
+        for (struct ExitFuncData *tmp = exit_func; tmp->func != nullptr && count < exit_func_size; tmp++, count++)
             tmp->func(tmp->data);
         pthread_mutex_unlock(&exit_mutex);
     }
     exit(exit_code);
 }
 
-int aFunTryExitPseudo() {
+/**
+ * 尝试执行退出函数
+ */
+int aFuntool::aFunTryExitPseudo() {
     if (pthread_mutex_trylock(&exit_mutex) == 0) {
         int count = 0;
-        for (struct ExitFuncData *tmp = exit_func; tmp->func != nullptr && count < EXIT_FUNC_SIZE; tmp++, count++) {
+        for (struct ExitFuncData *tmp = exit_func; tmp->func != nullptr && count < exit_func_size; tmp++, count++) {
             tmp->func(tmp->data);
             tmp->data = nullptr;
             tmp->func = nullptr;
@@ -33,10 +40,13 @@ int aFunTryExitPseudo() {
     return 0;
 }
 
-int aFunExitPseudo(void) {
+/**
+ * 执行退出函数, 但不退出
+ */
+int aFuntool::aFunExitPseudo() {
     if (pthread_mutex_lock(&exit_mutex) == 0) {
         int count = 0;
-        for (struct ExitFuncData *tmp = exit_func; tmp->func != nullptr && count < EXIT_FUNC_SIZE; tmp++, count++) {
+        for (struct ExitFuncData *tmp = exit_func; tmp->func != nullptr && count < exit_func_size; tmp++, count++) {
             tmp->func(tmp->data);
             tmp->data = nullptr;
             tmp->func = nullptr;
@@ -47,12 +57,17 @@ int aFunExitPseudo(void) {
     return 0;
 }
 
-int aFunAtExitTry(aFunExitFunc *func, void *data) {
+/**
+ * 尝试注册退出函数, 若锁占用则返回-1
+ * @param func 退出函数
+ * @param data 参数
+ */
+int aFuntool::aFunAtExitTry(aFunExitFunc *func, void *data) {
     if (pthread_mutex_trylock(&exit_mutex) == 0) {
         struct ExitFuncData *tmp = exit_func;
         int count = 0;
         for(NULL; tmp->func != nullptr; tmp++, count++) {
-            if (count >= EXIT_FUNC_SIZE) {
+            if (count >= exit_func_size) {
                 pthread_mutex_unlock(&exit_mutex);
                 return -1;
             }
@@ -65,12 +80,18 @@ int aFunAtExitTry(aFunExitFunc *func, void *data) {
     return -1;
 }
 
-int aFunAtExit(aFunExitFunc *func, void *data) {
+/**
+ * 注册退出函数, aFun退出函数会在atexit退出函数之前执行
+ * @param func 退出函数
+ * @param data 参数
+ * @return
+ */
+int aFuntool::aFunAtExit(aFunExitFunc *func, void *data) {
     if (pthread_mutex_lock(&exit_mutex) == 0) {
         struct ExitFuncData *tmp = exit_func;
         int count = 0;
         for(NULL; tmp->func != nullptr; tmp++, count++) {
-            if (count >= EXIT_FUNC_SIZE) {
+            if (count >= exit_func_size) {
                 pthread_mutex_unlock(&exit_mutex);
                 return -1;
             }

src/tool/file.cpp

@@ -5,11 +5,11 @@
 
 #include <sys/stat.h>
 #include <cctype>
-#include <cassert>
 #include <cstdio>
 #include <cstdlib>
 
 #include "tool.hpp"
+using namespace aFuntool;
 
 #ifdef aFunWIN32_NO_CYGWIN
 #ifdef _MSC_VER
@@ -36,13 +36,19 @@ typedef struct stat aFun_stat;
 typedef char aFun_path;
 #endif
 
-static int get_stat(aFun_stat *stat_, const char *path_){
+/**
+ * 获取文件的stat结构体
+ * @param stat stat 保存地址
+ * @param path 路径 (utf-8)
+ * @return
+ */
+static int get_stat(aFun_stat &stat_, const std::string &path_){
     int re;
 #ifdef aFunWIN32_NO_CYGWIN
     aFun_path *tmp = nullptr;
-    if (convertWideByte(&tmp, path_, CP_UTF8) == 0)
+    if (convertWideByte(&tmp, path_.c_str(), CP_UTF8) == 0)
         return -1;
-    re = _wstat64(tmp, stat_);
+    re = _wstat64(tmp, &stat_);
     free(tmp);  // 如果 path 为nullptr, 则释放最新生成的 wchat_t
 #else
     re = stat(path_, stat_);
@@ -50,17 +56,16 @@ static int get_stat(aFun_stat *stat_, const char *path_){
     return re;
 }
 
-/*
- * 函数名: checkFile
+/**
  * 目标判断文件类型, 若是普通文件返回1, 若是文件夹返回2, 其他遇到错误返回0
  */
-int checkFile(const char *path_){
-    if (path_ == nullptr)
+int aFuntool::checkFile(const std::string &path){
+    if (path.empty())
         return 0;
 
     int re = 0;
     aFun_stat stat;
-    if (get_stat(&stat, path_) != 0)
+    if (get_stat(stat, path) != 0)
         re = 0;
     else if (S_ISREG(stat.st_mode))  // 普通文件
         re = 1;
@@ -69,156 +74,135 @@ int checkFile(const char *path_){
     return re;
 }
 
-time_t getFileMTime(const char *path) {
+/**
+ * 获取文件最后修改时间
+ */
+time_t aFuntool::getFileMTime(const std::string &path) {
     aFun_stat stat;
-    if (path == nullptr || get_stat(&stat, path) != 0)
+    if (path.empty() || get_stat(stat, path) != 0)
         return 0;
     return stat.st_mtime;
 }
 
-char *joinPath(const char *path, const char *name, const char *suffix) {
-    char *name_suffix = strJoin(name, suffix, false, false);
-    char *res;
-
-    if (path != nullptr && path[STR_LEN(path) - 1] == SEP_CH)
-        res = strJoin(path, name_suffix, false, true);
-    else if (path != nullptr) {
-        res = strJoin(path, SEP, false, false);
-        res = strJoin(res, name_suffix, true, true);
-    } else
-        res = name_suffix;
-
-    /* name_suffix已经在上述的strJoin释放 */
-    return res;
+/**
+ * 拼接路径
+ * @param path 路径
+ * @param name 文件名
+ * @param suffix 后缀
+ * @return
+ */
+std::string aFuntool::joinPath(const std::string &path, const std::string &name, const std::string &suffix) {
+    std::string name_suffix = name + suffix;
+    if (!path.empty() && *(path.end()) == SEP_CH)
+        return path + name_suffix;
+    else if (!path.empty())
+        return path + SEP + name_suffix;
+    return name_suffix;
 }
 
-/*
- * 函数: getFileName
- * 目标: 给定路径获取该路径所指定的文件名
+/**
+ * 给定路径获取该路径所指定的文件名
  */
-char *getFileName(const char *path_1){
-    char *path = strCopy(path_1);  // 复制数组, 避免path_1是常量字符串导致无法修改其值
-    char *slash;  // 名字开始的字符的指针
-    char *point;  // 后缀名.所在的字符的指针
-
-    if (path[STR_LEN(path) - 1] == SEP_CH)  // 若路径的最后一个字符为SEP, 则忽略此SEP
-        path[STR_LEN(path) - 1] = NUL;
-
-    if ((slash = strrchr(path, SEP_CH)) == nullptr)
-        slash = path;
+std::string aFuntool::getFileName(const std::string &path){
+    int sep = 0;
+    if (*(path.end()) == SEP_CH)  // 若路径的最后一个字符为SEP, 则忽略此SEP
+        sep = -1;
+
+    auto slash = path.find_last_of('/');
+    if (slash == std::string::npos)
+        slash = 0;
     else
         slash++;
 
-    if ((point = getFileSurfix(path)) != nullptr)
-        *point = NUL;
-
-    char *res = strCopy(slash);
-    free(path);
-    return res;
+    return path.substr(path.size() - slash + sep, slash);
 }
 
-/*
- * 函数名: getFileNameWithPath
- * 目标: 取出指定路径的文件后缀
+/**
+ * 获取 文件路径+文件名（排除后缀）
  */
-char *getFileNameWithPath(const char *path_1){
-    char *path = strCopy(path_1);  // 复制数组, 避免path_1是常量字符串导致无法修改其值
-    char *point;  // 后缀名.所在的字符的指针
-    char *res;
-
-    if ((point = getFileSurfix(path)) != nullptr)
-        *point = NUL;
-
-    res = strCopy(path);
-    free(path);
-    return res;
+std::string aFuntool::getFilePathName(const std::string &path){
+    auto point = path.find_last_of('.');
+    if (point == std::string::npos)
+        return path;
+    return path.substr(point);
 }
 
-char *getFilePath(const char *path_1, int dep){
-    char *path = strCopy(path_1);  // 复制数组, 避免path_1是常量字符串导致无法修改其值
-    char *slash;  // 后缀名.所在的字符的指针
-    char *res;
-
-    if (path[STR_LEN(path) - 1] == SEP_CH)  // 若路径的最后一个字符为SEP, 则忽略此SEP
-        path[STR_LEN(path) - 1] = NUL;
-
-    for(NULL; dep > 0; dep--) {
-        if ((slash = strrchr(path, SEP_CH)) != nullptr)
-            *slash = NUL;
+/**
+ * 获取文件路径(不包含文件名)
+ */
+std::string aFuntool::getFilePath(const std::string &path, int dep){
+    std::string::size_type point = path.size();
+    for (int i = 0; i < dep; i++) {
+        auto tmp = path.rfind('.', point);
+        if (tmp == std::string::npos)
+            break;
+        point = tmp;
     }
-
-    res = strCopy(path);
-    free(path);
-    return res;
+    return path.substr(point);
 }
 
-/*
- * 函数名: getFileSurfix
- * 目标: 获取文件后缀 (不会生成新字符串)
+/**
+ * 获取文件后缀
  */
-char *getFileSurfix(const char *path) {
-    const char *last_ = strrchr(path, SEP_CH);
-    char *ret;
-
-    if (last_ != nullptr)
-        ret = const_cast<char *>(strrchr(last_ + 1, '.'));
+std::string aFuntool::getFileSurfix(const std::string &path) {
+    auto point = path.find_last_of('.');
+    if (point == std::string::npos)
+        point = 0;
     else
-        ret = const_cast<char *>(strrchr(path, '.'));
+        point++;
+
+    std::string ret = path.substr(path.size() - point, point);
     return ret;
 }
 
-/*
- * 函数名: fileNameToVar
- * 目标: 把一个文件名转换为合法的变量名(替换不合法字符为_)
+/**
+ * 把一个文件名转换为合法的变量名(替换不合法字符为_)
+ * @param name 路径
+ * @param need_free 是否需要释放
  */
-char *fileNameToVar(char *name, bool need_free){
-    char *var;
-    if (need_free)
-        var = name;  // 在原数据上修改
-    else
-        var = strCopy(name);  // 复制新的数据再修改
+std::string aFuntool::fileNameToVar(const std::string &name){
+    char *var = strCopy(name.c_str());  // 复制新的数据再修改
 
     if (!isalpha(*var) && *var != '_')
         var = strJoin("_", var, false, true);
     for (char *tmp = var; *tmp != 0; tmp++)
         if (!isalnum(*tmp) &&'_' != *tmp)
             *tmp = '_';
-    return var;
+    std::string ret = var;
+    free(var);
+    return ret;
 }
 
-/*
- * 函数名: findPath
- * 目标: 转换路径为合法路径（相对路径->绝对路径, 绝对路径保持不变）
+/**
+ * 转换路径为合法路径（相对路径->绝对路径, 绝对路径保持不变）
+ * @param path 文件路径
+ * @param env 环境 必须以 / 结尾
+ * @param need_free 是否需要释放 path
  */
-char *findPath(char *path, const char *env, bool need_free){
-    assert(env[STR_LEN(env) - 1] == SEP_CH);  // env 必须以 SEP 结尾
+std::string aFuntool::findPath(const std::string &path, const std::string &env){
 #ifdef __linux
-    if (path[0] != SEP_CH) { // 不以 / 开头
+    if (path[0] != SEP_CH) // 不以 / 开头
 #else
-    if (!(isupper(path[0]) && (path)[1] == ':')) {  // 不以盘符开头
+    if (!(isupper(path[0]) && (path)[1] == ':'))  // 不以盘符开头
 #endif
-        return strJoin(env, path, false, need_free);  // 调整为相对路径模式
-    } else if (!need_free) { // 若设置了need_free为true, 则等于先复制在释放原来的, 等于没有复制， 所以不做操作
-        return strCopy(path);
-    } else {
-        return path;
-    }
+        return env + path;  // 调整为相对路径模式
+    return path;
 }
 
-/*
- * 函数名: 获取可执行程序目录
- * dep表示从可执行程序往回跳出的层数
+/**
+ * 获取可执行程序目录
+ * @param dep 从可执行程序往回跳出的层数
  */
-char *getExedir(int dep) {
+std::string aFuntool::getExedir(int dep) {
     aFun_path exepath[218] = {0};
 #ifdef aFunWIN32_NO_CYGWIN
     DWORD ret = GetModuleFileNameW(nullptr, exepath, 217);  // 预留一位给NUL
-    if (ret == 0 || WSTR_LEN(exepath) == 0)
-        return nullptr;
+    if (ret == 0 || wcslen(exepath) == 0)
+        return "";
     char *path = nullptr;
     if (convertFromWideByte(&path, exepath, CP_UTF8) == 0)
-        return nullptr;
-    char *re = getFilePath(path, dep + 1);
+        return "";
+    std::string re = getFilePath(path, dep + 1);
     free(path);
     return re;
 #else
@@ -229,21 +213,24 @@ char *getExedir(int dep) {
 #endif
 }
 
-uintmax_t getFileSize(const char *path) {
+/**
+ * @param path 文件路径 (utf-8)
+ * @return 文件大小
+ */
+uintmax_t aFuntool::getFileSize(const std::string &path) {
     aFun_stat stat;
     int ret;
-    ret = get_stat(&stat, path);
+    ret = get_stat(stat, path);
     if(ret != 0)
         return 0;  // 获取失败。
     return (uintmax_t)stat.st_size;  // 返回文件大小
-
 }
 
-/*
- * 函数名: isCharUTF8
- * 目标: 检查给定字符串是否utf-8编码
+/**
+ * 检查给定字符串是否utf-8编码
+ * @param str 字符串
  */
-bool isCharUTF8(const char *str) {
+bool aFuntool::isCharUTF8(const char *str) {
     int code = 0;  // utf-8 多字节数
     for (const char *ch = str; *ch != NUL; ch++) {
         unsigned char c = *ch;
@@ -274,8 +261,18 @@ bool isCharUTF8(const char *str) {
     return true;
 }
 
-FILE *fileOpen(const char *path_, const char *mode_) {
-    if (STR_LEN(mode_) >= 5)
+bool aFuntool::isCharUTF8(const std::string &str) {
+    return isCharUTF8(str.c_str());
+}
+
+/**
+ * 打开指定文件
+ * @param path_ 路径 (utf-8)
+ * @param mode_ 模式
+ * @return
+ */
+FILE *aFuntool::fileOpen(const char *path_, const char *mode_) {
+    if (strlen(mode_) >= 5)
         return nullptr;
 #ifdef aFunWIN32_NO_CYGWIN
     FILE *file = nullptr;
@@ -294,6 +291,15 @@ FILE *fileOpen(const char *path_, const char *mode_) {
 #endif
 }
 
-int fileClose(FILE *file) {
+FILE *aFuntool::fileOpen(const std::string &path_, const char *mode_) {
+    return fileOpen(path_.c_str(), mode_);
+}
+
+/**
+ * 关闭文件, 本质和fclose一样
+ * @param file FILE
+ * @return
+ */
+int aFuntool::fileClose(FILE *file) {
     return fclose(file);
 }

src/tool/hash.cpp

@@ -4,10 +4,18 @@
  */
 
 #include "tool.hpp"
+using namespace aFuntool;
 
-time33_t time33(const char *str) {
+time33_t aFuntool::time33(const char *str) {
     unsigned int hash = 5381;
     while(*str)
         hash += (hash << 5 ) + (*str++);
-    return (hash & 0x7FFFFFFF);
+    return (hash & 0x7FFFFFFF);  // NOLINT
+}
+
+time33_t aFuntool::time33(const std::string &str) {
+    unsigned int hash = 5381;
+    for (auto ch : str)
+        hash += (hash << 5 ) + ch;
+    return (hash & 0x7FFFFFFF);  // NOLINT
 }

src/tool/log.cpp

@@ -17,6 +17,7 @@
 #include <cstdarg>
 #include <cstring>
 #include "tool.hpp"
+using namespace aFuntool;
 
 #ifdef aFunWIN32
 #include <windows.h>
@@ -32,47 +33,43 @@
 
 #undef calloc
 
-typedef struct LogNode LogNode;
-struct LogNode {  // 日志信息记录节点
-    LogLevel level;
-    const char *id;
-    pid_t tid;
-    char *date;  // 需要释放
-    time_t time;
-    const char *file;
-    int line;
-    const char *func;
-    char *info;  // 需要释放
-
-    LogNode *next;
-};
-
-static struct LogFactory {
-    bool init;  // 是否已经初始化
-    pid_t pid;
-
-    FILE *log;  // 记录文件输出的位置
-    FILE *csv;
+namespace aFuntool {
+    typedef struct LogNode LogNode;
+    struct LogNode {  // 日志信息记录节点
+        LogLevel level = log_info;
+        const char *id = "SYSTEM";
+        pid_t tid = 0;
+        char *date = nullptr;  // 需要释放
+        time_t time = 0;
+        const char *file = "unknown";
+        int line = 1;
+        const char *func = "unknown";
+        char *info = nullptr;  // 需要释放
+
+        LogNode *next = nullptr;
+    };
+
+    LogFactory log_factory {};  // NOLINT
+}
 
-    Logger sys_log;
+struct ansyData {
+    pthread_mutex_t *mutex;
+};
 
-    bool asyn;  // 异步
-    pthread_t pt;
-    pthread_cond_t cond;  // 有日志
-    LogNode *log_buf;
-    LogNode **plog_buf;  // 指向 log_buf的末端
-} log_factory = {.init=false};
-static pthread_mutex_t log_factory_mutex = PTHREAD_MUTEX_INITIALIZER;
-#define MUTEX (&log_factory_mutex)
+static void destructLogSystemAtExit(void *);
+static void *ansyWritrLog(void *);
 
-static void destructLogSystemAtExit(void *_);
-static void *ansyWritrLog_(void *_);
+aFuntool::LogFactory::LogFactory() {  // NOLINT cond 通过 pthread_cond_init 实现初始化
+    init=false;
+    pid=0;
+    log = nullptr;
+    csv = nullptr;
 
-/**
- * 输出日志系统的相关信息, Debug使用
- */
-void printLogSystemInfo() {
-    printf("Log system on %p\n", &log_factory);
+    asyn=false;
+    pt = 0;
+    pthread_cond_init(&cond, nullptr);
+    log_buf = nullptr;
+    plog_buf = nullptr;
 }
 
 /**
@@ -85,115 +82,118 @@ void printLogSystemInfo() {
  *
  * 该程序线程不安全
  * @param path 日志保存的地址
- * @param asyn 是否启用异步
+ * @param is_asyn 是否启用异步
  * @return
  */
-int initLogSystem(FilePath path, bool asyn){
-    if (strlen(path) >= 218)  // 路径过长
+int aFuntool::LogFactory::initLogSystem(ConstFilePath path, bool is_asyn){
+    if (path.size() >= 218)  // 路径过长
         return 0;
 
     int re = 1;
-    pthread_mutex_lock(MUTEX);
-    if (log_factory.init) {
-        pthread_mutex_unlock(MUTEX);
+    pthread_mutex_lock(&mutex);
+    if (init) {
+        pthread_mutex_unlock(&mutex);
         return 2;
     }
 
     char log_path[218] = {0};
     char csv_path[218] = {0};
-    log_factory.pid = getpid();  // 获取进程ID
+    pid = getpid();  // 获取进程ID
 
     char *ti = getTime(nullptr, (char *)"%Y-%m-%d%z");
-    snprintf(log_path, 218, "%s-%s.log", path, ti);
-    snprintf(csv_path, 218, "%s-%s.csv", path, ti);
+    snprintf(log_path, 218, "%s-%s.log", path.c_str(), ti);
+    snprintf(csv_path, 218, "%s-%s.csv", path.c_str(), ti);
     free(ti);
 
     uintmax_t log_size = getFileSize(log_path);
     uintmax_t csv_size = getFileSize(csv_path);
     bool csv_head_write = (checkFile(csv_path) == 0);  // 文件不存在时才写入头部
 
-    log_factory.log = fileOpen(log_path, (char *)"a");
-    if (log_factory.log == nullptr) {
+    log = fileOpen(log_path, (char *)"a");
+    if (log == nullptr) {
         perror("ERROR: ");
         printf("log_path = %s\n", log_path);
-        pthread_mutex_unlock(MUTEX);
+        pthread_mutex_unlock(&mutex);
         return 0;
     }
 
-    log_factory.csv = fileOpen(csv_path, (char *)"a");
-    if (log_factory.csv == nullptr) {
-        pthread_mutex_unlock(MUTEX);
+    csv = fileOpen(csv_path, (char *)"a");
+    if (csv == nullptr) {
+        pthread_mutex_unlock(&mutex);
         return 0;
     }
 
 #define CSV_FORMAT "%s,%s,%d,%d,%s,%ld,%s,%d,%s,%s\n"
 #define CSV_TITLE  "Level,Logger,PID,TID,Data,Timestamp,File,Line,Function,Log\n"
     if (csv_head_write) {
-        fprintf(log_factory.csv, CSV_TITLE);  // 设置 cvs 标题
-        fflush(log_factory.csv);
+        fprintf(csv, CSV_TITLE);  // 设置 cvs 标题
+        fflush(csv);
     }
 #undef CSV_TITLE
 
-    log_factory.init = true;
-    log_factory.asyn = asyn;
-    if (log_factory.asyn) {
-        log_factory.plog_buf = &log_factory.log_buf;
-        pthread_cond_init(&log_factory.cond, nullptr);
-        pthread_create(&log_factory.pt, nullptr, ansyWritrLog_, nullptr);
+    init = true;
+    asyn = is_asyn;
+    if (is_asyn) {
+        plog_buf = &log_buf;
+        pthread_cond_init(&cond, nullptr);
+
+        auto *data = new ansyData;
+        data->mutex = &mutex;
+        pthread_create(&pt, nullptr, ansyWritrLog, data);
     }
 
-    initLogger(&(log_factory.sys_log), "SYSTEM", log_info);  // 设置为 debug, 记录 success 信息
-    pthread_mutex_unlock(MUTEX);
-    writeInfoLog(nullptr, "Log system init success");
-    writeInfoLog(nullptr, "Log .log size %lld", log_size);
-    writeInfoLog(nullptr, "Log .csv size %lld", csv_size);
+    sys_log = Logger("SYSTEM", log_info);  // 设置为 debug, 记录 success 信息
+    pthread_mutex_unlock(&mutex);
+    infoLog(nullptr, "Log system init success");
+    infoLog(nullptr, "Log .log size %lld", log_size);
+    infoLog(nullptr, "Log .csv size %lld", csv_size);
     aFunAtExit(destructLogSystemAtExit, nullptr);
     return re;
 }
 
-static void destructLogSystemAtExit(void *_) {
-    destructLogSystem();
+static void destructLogSystemAtExit(void *) {
+    log_factory.destruct();
 }
 
-int destructLogSystem() {
-    int re = 1;
-    pthread_mutex_lock(MUTEX);
-    if (!log_factory.init) {
-        re = 2;
+aFuntool::LogFactory::~LogFactory(){
+    destruct();
+}
+
+bool aFuntool::LogFactory::destruct() {
+    bool re = true;
+    pthread_mutex_lock(&mutex);
+    if (!init) {
+        re = false;
         goto RETURN;
     }
-    pthread_mutex_unlock(MUTEX);
 
-    writeInfoLog(nullptr, "Log system destruct by exit.");  // 需要用锁
+    pthread_mutex_unlock(&mutex);
+
+    infoLog(nullptr, "Log system destruct by exit.");  // 需要用锁
 
-    pthread_mutex_lock(MUTEX);
-    log_factory.init = false;
-    if (log_factory.asyn) {
-        pthread_mutex_unlock(MUTEX);
-        pthread_cond_signal(&log_factory.cond);
+    pthread_mutex_lock(&mutex);
+    init = false;
+    if (asyn) {
+        pthread_mutex_unlock(&mutex);
+        pthread_cond_signal(&cond);
 
-        pthread_join(log_factory.pt, nullptr);
+        pthread_join(pt, nullptr);
 
-        pthread_mutex_lock(MUTEX);
-        pthread_cond_destroy(&log_factory.cond);
-        if (log_factory.log_buf != nullptr)
+        pthread_mutex_lock(&mutex);
+        pthread_cond_destroy(&cond);
+        if (log_buf != nullptr)
             printf_stderr(0, "Logsystem destruct error.");
     }
 
-    fileClose(log_factory.log);
-    fileClose(log_factory.csv);
-    log_factory.log = nullptr;
-    log_factory.csv = nullptr;
+    fileClose(log);
+    fileClose(csv);
+    log = nullptr;
+    csv = nullptr;
 RETURN:
-    pthread_mutex_unlock(MUTEX);
+    pthread_mutex_unlock(&mutex);
     return re;
 }
 
-void initLogger(Logger *logger, const char *id, LogLevel level) {
-    memset(logger, 0, sizeof(Logger));
-    logger->id = id;
-    logger->level = level;
-}
 
 /* LogLevel和字符串的转换 */
 static const char *LogLevelName[] = {
@@ -229,20 +229,20 @@ static const char *LogLevelNameLong[] = {
  * @param func 函数名
  * @param info 日志内容
  */
-static void writeLogToFactory_(LogLevel level,
+void aFuntool::LogFactory::writeLog(LogLevel level,
                                const char *id, pid_t tid,
                                const char *ti, time_t t,
                                const char *file, int line, const char *func,
                                const char *info) {
 #define FORMAT "%s/[%s] %d %d {%s %ld} (%s:%d at %s) : '%s' \n"
     /* 写入文件日志 */
-    if (log_factory.log != nullptr) {
-        fprintf(log_factory.log, FORMAT, LogLevelName[level], id, log_factory.pid, tid, ti, t, file, line, func, info);
-        fflush(log_factory.log);
+    if (log != nullptr) {
+        fprintf(log, FORMAT, LogLevelName[level], id, pid, tid, ti, t, file, line, func, info);
+        fflush(log);
     }
-    if (log_factory.csv != nullptr) {
-        fprintf(log_factory.csv, CSV_FORMAT, LogLevelName[level], id, log_factory.pid, tid, ti, t, file, line, func, info);
-        fflush(log_factory.csv);
+    if (csv != nullptr) {
+        fprintf(csv, CSV_FORMAT, LogLevelName[level], id, pid, tid, ti, t, file, line, func, info);
+        fflush(csv);
     }
 
 #undef FORMAT
@@ -261,13 +261,13 @@ static void writeLogToFactory_(LogLevel level,
  * @param func 函数名
  * @param info 日志内容
  */
-static void writeLogToConsole_(LogLevel level,
-                               const char *id, pid_t tid,
-                               const char *ti, time_t t,
-                               const char *file, int line, const char *func,
-                               const char *info) {
+void aFuntool::LogFactory::writeConsole(LogLevel level,
+                                        const char *id, pid_t tid,
+                                        const char *ti, time_t t,
+                                        const char *file, int line, const char *func,
+                                        const char *info) {
 #define FORMAT_SHORT "\r* %s[%d] %s %ld (%s:%d) : %s \n"  // 显示到终端, 添加\r回车符确保顶行显示
-#define STD_BUF_SIZE (STR_LEN(info) + 1024)
+#define STD_BUF_SIZE (strlen(info) + 1024)
     if (level < log_warning) {
         printf_stdout(STD_BUF_SIZE, FORMAT_SHORT, LogLevelNameLong[level], tid, ti, t, file, line, info);
         fflush(stdout);
@@ -291,12 +291,12 @@ static void writeLogToConsole_(LogLevel level,
  * @param func 函数名
  * @param info 日志内容
  */
-static void writeLogToAsyn_(LogLevel level,
-                            const char *id, pid_t tid,
-                            const char *ti, time_t t,
-                            const char *file, int line, const char *func, const char *info) {
-#define D(i) (*(log_factory.plog_buf))->i
-    *(log_factory.plog_buf) = (LogNode *)calloc(1, sizeof(LogNode));
+void aFuntool::LogFactory::writeLogAsyn(LogLevel level,
+                                        const char *id, pid_t tid,
+                                        const char *ti, time_t t,
+                                        const char *file, int line, const char *func, const char *info) {
+#define D(i) (*(plog_buf))->i
+    *(plog_buf) = new aFuntool::LogNode;
     D(level) = level;
     D(id) = id;
     D(tid) = tid;
@@ -310,30 +310,41 @@ static void writeLogToAsyn_(LogLevel level,
 #undef D
 }
 
+
+aFuntool::LogNode *aFuntool::LogFactory::pop(){
+    struct LogNode *n = log_buf;
+    if (n != nullptr) {
+        log_buf = n->next;
+        if (log_buf == nullptr)
+            plog_buf = &log_buf;
+    }
+    return n;
+}
+
+
 /**
  * 异步写入日志程序
- * @param _ 无意义
  * @return
  */
-static void *ansyWritrLog_(void *_) {
-    pthread_mutex_lock(MUTEX);
+static void *ansyWritrLog(void *d) {
+    auto *data = (struct ansyData *)d;
+    pthread_mutex_lock(data->mutex);
     while (true) {
-        while (log_factory.init && log_factory.log_buf == nullptr)
-            pthread_cond_wait(&log_factory.cond, MUTEX);
-        if (!log_factory.init && log_factory.log_buf == nullptr)
+        while (!log_factory.news())
+            log_factory.wait();
+        if (log_factory.stop())
             break;
-#define D(i) log_factory.log_buf->i
-        writeLogToFactory_(D(level), D(id), D(tid), D(date), D(time), D(file), D(line), D(func), D(info));
+
+        LogNode *tmp = log_factory.pop();
+#define D(i) tmp->i
+        log_factory.writeLog(D(level), D(id), D(tid), D(date), D(time), D(file), D(line), D(func), D(info));
 #undef D
-        LogNode *tmp = log_factory.log_buf->next;
-        free(log_factory.log_buf->date);
-        free(log_factory.log_buf->info);
-        free(log_factory.log_buf);
-        log_factory.log_buf = tmp;
-        if (tmp == nullptr)
-            log_factory.plog_buf = &log_factory.log_buf;
+        free(tmp->date);
+        free(tmp->info);
+        delete tmp;
     }
-    pthread_mutex_unlock(MUTEX);
+    pthread_mutex_unlock(data->mutex);
+    delete data;
     return nullptr;
 }
 
@@ -349,142 +360,132 @@ static void *ansyWritrLog_(void *_) {
  * @param ap 格式字符串内容
  * @return
  */
-static int writeLog_(Logger *logger, 
-                     bool pc, 
-                     LogLevel level, 
-                     const char *file, int line, const char *func,
-                     const char *format, va_list ap){
+int aFuntool::LogFactory::newLog(Logger *logger,
+                                 bool pc,
+                                 LogLevel level,
+                                 const char *file, int line, const char *func,
+                                 const char *format, va_list ap){
     if (logger->level > level)
         return 2;
 
-    pthread_mutex_lock(MUTEX);
-    if (!log_factory.init || log_factory.log == nullptr) {
-        pthread_mutex_unlock(MUTEX);
+    pthread_mutex_lock(&mutex);
+    if (!init || log == nullptr) {
+        pthread_mutex_unlock(&mutex);
         return 1;
     }
-    CLEAR_FERROR(log_factory.log);
+    clear_ferror(log);
 
     // 输出 head 信息
     time_t t = 0;
-    char *ti = getTime(&t, "%Y-%m-%d %H:%M:%S");
+    char *ti = getTime(&t, ("%Y-%m-%d %H:%M:%S"));
     pid_t tid = gettid();
 
     char tmp[2048] = {0};
     vsnprintf(tmp, 1024, format, ap);  // ap只使用一次
     va_end(ap);
 
-    if (log_factory.asyn)
-        writeLogToAsyn_(level, logger->id, tid, ti, t, file, line, func, tmp);
+    if (asyn)
+        writeLogAsyn(level, logger->id.c_str(), tid, ti, t, file, line, func, tmp);
     else
-        writeLogToFactory_(level, logger->id, tid, ti, t, file, line, func, tmp);
+        writeLog(level, logger->id.c_str(), tid, ti, t, file, line, func, tmp);
 
     if (pc)
-        writeLogToConsole_(level, logger->id, tid, ti, t, file, line, func, tmp);
+        writeConsole(level, logger->id.c_str(), tid, ti, t, file, line, func, tmp);
 
-    pthread_mutex_unlock(MUTEX);
-    if (log_factory.asyn)
-        pthread_cond_signal(&log_factory.cond);
+    pthread_mutex_unlock(&mutex);
+    if (asyn)
+        pthread_cond_signal(&cond);
     free(ti);
     return 0;
 }
 
 #define CHECK_LOGGER() do {if (logger == nullptr) {logger = &(log_factory.sys_log);} \
-                           if (logger == nullptr || logger->id == nullptr) return -1;} while(0)
+                           if (logger == nullptr) return -1;} while(0)
 
-int writeTrackLog_(Logger *logger,
-                   const char *file, int line, const char *func,
-                   const char *format, ...) {
-#if aFunWriteTrack
-    CHECK_LOGGER();
+aFuntool::Logger::Logger(const std::string &id, LogLevel level, bool exit) {
+    this->id = id;
+    this->level = level;
+    this->exit = exit;
+}
 
+#undef trackLog
+int aFuntool::Logger::writeTrackLog(const char *file, int line, const char *func,
+                                    const char *format, ...) {
+#if aFunWriteTrack
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, aFunConsoleTrack, log_track, file, line, func, format, ap);
+    return log_factory.newLog(this, aFunConsoleTrack, log_track, file, line, func, format, ap);
 #endif
 }
 
-int writeDebugLog_(Logger *logger,
-                   const char *file, int line, const char *func,
-                   const char *format, ...) {
+#undef debugLog
+int aFuntool::Logger::writeDebugLog(const char *file, int line, const char *func,
+                                    const char *format, ...) {
 #if aFunWriteDebug
-    CHECK_LOGGER();
-
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, aFunConsoleDebug, log_debug, file, line, func, format, ap);
+    return log_factory.newLog(this, aFunConsoleDebug, log_debug, file, line, func, format, ap);
 #endif
 }
 
-int writeInfoLog_(Logger *logger,
-                  const char *file, int line, const char *func,
-                  const char *format, ...) {
+#undef infoLog
+int aFuntool::Logger::writeInfoLog(const char *file, int line, const char *func,
+                                   const char *format, ...) {
 #if aFunWriteInfo
-    CHECK_LOGGER();
-
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, aFunConsoleInfo, log_info, file, line, func, format, ap);
+    return log_factory.newLog(this, aFunConsoleInfo, log_info, file, line, func, format, ap);
 #endif
 }
 
-int writeWarningLog_(Logger *logger,
-                     const char *file, int line, const char *func,
-                     const char *format, ...) {
+#undef warningLog
+int aFuntool::Logger::writeWarningLog(const char *file, int line, const char *func,
+                                      const char *format, ...) {
 #if !aFunIgnoreWarning
-    CHECK_LOGGER();
-
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, aFunConsoleWarning, log_warning, file, line, func, format, ap);
+    return log_factory.newLog(this, aFunConsoleWarning, log_warning, file, line, func, format, ap);
 #endif
 }
 
-int writeErrorLog_(Logger *logger,
-                   const char *file, int line, const char *func,
-                   const char *format, ...) {
+#undef errorLog
+int aFuntool::Logger::writeErrorLog(const char *file, int line, const char *func,
+                                    const char *format, ...) {
 #if !aFunIgnoreError
-    CHECK_LOGGER();
-
     va_list ap;
     va_start(ap, format);
-    return writeLog_(logger, aFunConsoleError, log_error, file, line, func, format, ap);
+    return log_factory.newLog(this, aFunConsoleError, log_error, file, line, func, format, ap);
 #endif
 }
 
-int writeSendErrorLog_(Logger *logger,
-                       const char *file, int line, const char *func,
-                       const char *format, ...) {
+#undef sendErrorLog
+int aFuntool::Logger::writeSendErrorLog(const char *file, int line, const char *func,
+                                        const char *format, ...) {
 #ifndef aFunOFFAllLog
-    CHECK_LOGGER();
 #if !aFunIgnoreSendError
     va_list ap;
     va_start(ap, format);
-    jmp_buf *buf = logger->buf;
-    writeLog_(logger, aFunConsoleSendError, log_send_error, file, line, func, format, ap);
+    log_factory.newLog(this, aFunConsoleSendError, log_send_error, file, line, func, format, ap);
 #endif
 
-    destructLogSystem();
-    if (buf != nullptr) {
-        initLogger(logger, nullptr, LogLevel(0));  // 清零
-        longjmp(*buf, 1);
-    } else
-        aFunExit(aFunExitFail);
+    if (this->exit)
+        throw LogFatalError("Log Fatal Error");
+    aFuntool::log_factory.destruct();
+    aFunExit(EXIT_FAILURE);
 #endif
 }
 
-int writeFatalErrorLog_(Logger *logger,
-                        const char *file, int line, const char *func,
-                        int exit_code, const char *format, ...) {
+#undef fatalErrorLog
+int aFuntool::Logger::writeFatalErrorLog(const char *file, int line, const char *func,
+                                         int exit_code, const char *format, ...) {
 #ifndef aFunOFFAllLog
-    CHECK_LOGGER();
-
 #if !aFunIgnoreFatal
     va_list ap;
     va_start(ap, format);
-    writeLog_(logger, aFunConsoleFatalError, log_fatal_error, file, line, func, format, ap);
+    log_factory.newLog(this, aFunConsoleFatalError, log_fatal_error, file, line, func, format, ap);
 #endif
 
-    destructLogSystem();
+    aFuntool::log_factory.destruct();
     if (exit_code == EXIT_SUCCESS)
         abort();
     else

src/tool/md5.cpp

@@ -7,12 +7,15 @@
 
 #include "tool.hpp"
 #include "__md5.hpp"
-
-struct MD5_CTX {
-    unsigned int count[2];
-    unsigned int state[4];
-    unsigned char buffer[64];
-};
+using namespace aFuntool;
+
+namespace aFuntool {
+    struct MD5_CTX {
+        unsigned int count[2];
+        unsigned int state[4];
+        unsigned char buffer[64];
+    };
+}
 
 static void MD5Transform(unsigned int state[4],unsigned char block[64]);
 static void MD5Encode(unsigned char *output,const unsigned int *input,unsigned int len);
@@ -25,8 +28,8 @@ unsigned char PADDING[] = {
                 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
         };
 
-MD5_CTX *MD5Init(void) {
-    MD5_CTX *context = calloc(1, MD5_CTX);
+MD5_CTX *aFuntool::MD5Init() {
+    auto context = calloc(1, MD5_CTX);
     context->count[0] = 0;
     context->count[1] = 0;
     context->state[0] = 0x67452301;
@@ -36,7 +39,7 @@ MD5_CTX *MD5Init(void) {
     return context;
 }
 
-void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int input_len) {
+void aFuntool::MD5Update(MD5_CTX *context, unsigned char *input, unsigned int input_len) {
     unsigned int i;
     unsigned int index;
     unsigned int part_len;
@@ -63,7 +66,7 @@ void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int input_len) {
     memcpy(&context->buffer[index], &input[i], input_len - i);
 }
 
-void MD5Final(MD5_CTX *context, unsigned char digest[16]) {
+void aFuntool::MD5Final(MD5_CTX *context, unsigned char digest[16]) {
     unsigned int index;
     unsigned int pad_len;
     unsigned char bits[8];
@@ -187,7 +190,8 @@ static void MD5Transform(unsigned int state[4], unsigned char block[64]) {
 }
 
 
-char *getFileMd5(char *path) {
+template <typename T>
+T aFuntool::getFileMd5(T &path) {
     FILE *fd;
 
     unsigned long ret;
@@ -195,11 +199,11 @@ char *getFileMd5(char *path) {
     unsigned char md5_value[MD5_SIZE];
 
     if ((fd = fileOpen(path, "rb")) == nullptr)
-        return nullptr;
+        throw aFuntool::FileOpenException();
 
     char *md5str = calloc(MD5_STRING, char);
     MD5_CTX *md5 = MD5Init();
-    while (1) {
+    while (true) {
         ret = fread(data, 1, READ_DATA_SIZE, fd);
         MD5Update(md5, data, ret);
         if (ret < READ_DATA_SIZE)
@@ -213,4 +217,7 @@ char *getFileMd5(char *path) {
         snprintf(md5str + i * 2, 2 + 1, "%02x", md5_value[i]);
 
     return md5str;
-}
+}
+
+template AFUN_TOOL_EXPORT char *aFuntool::getFileMd5(char *&path);
+template AFUN_TOOL_EXPORT std::string aFuntool::getFileMd5(std::string &path);

src/tool/regex.cpp

@@ -3,42 +3,29 @@
 
 #define PCRE2_CODE_UNIT_WIDTH 8
 #include "pcre2.h"
-#include "__regex.hpp"
+#include "regex.hpp"
+using namespace aFuntool;
 
-af_Regex *makeRegex(const char *pattern, char **error) {
-    if (error)
-        *error = nullptr;
-    if (!isCharUTF8(pattern)) {
-        *error = strCopy("Pattern not utf-8");
-        return nullptr;
-    }
+aFuntool::Regex::Regex(const std::string &pattern) {
+    if (!isCharUTF8(pattern))
+        throw RegexException("Pattern not utf-8");
 
     int error_code;
     size_t erroroffset;
     char regex_error[REGEX_ERROR_SIZE];
-    pcre2_code *re = pcre2_compile((PCRE2_SPTR)pattern, PCRE2_ZERO_TERMINATED, 0, &error_code, &erroroffset, nullptr);
 
+    this->pattern = pattern;
+    this->re = pcre2_compile((PCRE2_SPTR)pattern.c_str(), PCRE2_ZERO_TERMINATED, 0, &error_code, &erroroffset, nullptr);
     if (re == nullptr) {
-        if (error) {
-            PCRE2_UCHAR buffer[256];
-            pcre2_get_error_message(error_code, buffer, sizeof(buffer));
-
-            snprintf(regex_error, sizeof(regex_error), "Regex failed: %d: %s\n", (int) erroroffset, buffer);
-            *error = strCopy(regex_error);
-        }
-        return nullptr;
+        PCRE2_UCHAR buffer[256];
+        pcre2_get_error_message(error_code, buffer, sizeof(buffer));
+        snprintf(regex_error, sizeof(regex_error), "R%d: %s\n", (int) erroroffset, buffer);
+        throw RegexException(regex_error);
     }
-
-    auto rg = calloc(1, af_Regex);
-    rg->pattern = strCopy(pattern);
-    rg->re = re;
-    return rg;
 }
 
-void freeRegex(af_Regex *rg) {
-    pcre2_code_free(rg->re);
-    free(rg->pattern);
-    free(rg);
+aFuntool::Regex::~Regex() {
+    pcre2_code_free(re);
 }
 
 /*
@@ -48,50 +35,39 @@ void freeRegex(af_Regex *rg) {
  * 返回  (0) - 不可完全匹配或不可匹配
  * 返回 (>0) - 失败
  */
-int matchRegex(const char *subject, af_Regex *rg, char **error) {
-    if (error != nullptr)
-        *error = nullptr;
-    if (!isCharUTF8(subject)) {
-        if (error != nullptr)
-            *error = strCopy("Subject not utf-8");
-        return 0;
-    }
+int aFuntool::Regex::match(const char *subject) {
+    if (!isCharUTF8(subject))
+        throw RegexException("Subject not utf-8");
 
     char regex_error[REGEX_ERROR_SIZE];
-    auto sub = (PCRE2_SPTR)subject;
     PCRE2_SIZE sub_len = strlen(subject);
-    pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(rg->re, nullptr);
-    int rc = pcre2_match(rg->re, sub, sub_len, 0, 0, match_data, nullptr);
+    pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, nullptr);
+    int rc = pcre2_match(re, (PCRE2_SPTR)subject, sub_len, 0, 0, match_data, nullptr);
 
     if (rc < 0) {
         pcre2_match_data_free(match_data);
         if (rc == PCRE2_ERROR_NOMATCH)
             return 0;
         else {
-            if (error != nullptr) {
-                snprintf(regex_error, sizeof(regex_error), "Regex match '%s' failed by '%s'\n", subject, rg->pattern);
-                *error = strCopy(regex_error);
-            }
-            return -1;
+            snprintf(regex_error, sizeof(regex_error),
+                     "Regex match '%s' failed by '%s'\n", subject, pattern.c_str());
+            throw RegexException(regex_error);
         }
     }
 
     PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(match_data);
     if (ovector[0] > ovector[1]) {
-        if (error != nullptr) {
-            snprintf(regex_error, sizeof(regex_error),
-                     "\\K was used in an assertion to set the match start after its end.\n"
-                     "From end to start the match was: %.*s\n",
-                     (int) (ovector[0] - ovector[1]), (char *) (subject + ovector[1]));
-            *error = strCopy(regex_error);
-        }
+        snprintf(regex_error, sizeof(regex_error),
+                 "\\K was used in an assertion to set the match start after its end.\n"
+                 "From end to start the match was: %.*s\n",
+                 (int) (ovector[0] - ovector[1]), (char *) (subject + ovector[1]));
         pcre2_match_data_free(match_data);
-        return -2;
+        throw RegexException(regex_error);
     }
 
-    int result = 0;
+    int ret = 0;
     if (ovector[0] == 0 && ovector[1] == sub_len) // 完全匹配
-        result = 1;
+        ret = 1;
     pcre2_match_data_free(match_data);
-    return result;
+    return ret;
 }

src/tool/stdio_.cpp

@@ -9,6 +9,7 @@
 #include <cstdarg>
 #include <csignal>
 #include "tool.hpp"
+using namespace aFuntool;
 
 /* 注意:
  * checkStdin在Windows和Linux之前行为具有差别, 本质目标时检查缓冲区是否有内容
@@ -21,7 +22,7 @@
 // 获取CodePage, 并将内存中utf-8字符串转换为对应编码输出
 // cygwin环境下, 终端默认为uft-8
 
-#define BUFF_SIZE (40960)
+const int BUFF_SIZE = 40960;
 static char buffer[BUFF_SIZE + 1] = "";
 static size_t index = 0;
 static size_t next = 0;
@@ -215,7 +216,7 @@ static int fcheck_stdin(HANDLE std_i, HANDLE std_o) {
     return 1;
 }
 
-int fgetc_stdin() {
+int aFuntool::fgetc_stdin() {
     if (!_isatty(_fileno(stdin)))
         return fgetc(stdin);
 
@@ -239,7 +240,7 @@ RETURN:
     return re;
 }
 
-char *fgets_stdin_(char *buf, size_t len) {
+char *aFuntool::fgets_stdin_(char *buf, size_t len) {
     if (!_isatty(_fileno(stdin)))
         return fgets(buf, (int)len, stdin);
 
@@ -271,7 +272,7 @@ RETURN:
     return buf;
 }
 
-bool fclear_stdin() {
+bool aFuntool::fclear_stdin() {
     if (!_isatty(_fileno(stdin))) {
         rewind(stdin);  // 仅 winAPI 可用
         return true;
@@ -291,7 +292,11 @@ bool fclear_stdin() {
     return false;
 }
 
-void stdio_signal_init(bool signal) {
+/**
+ * 接管ctrl+c信号初始化
+ * @param signal 初始化/还原
+ */
+void aFuntool::stdio_signal_init(bool signal) {
     HANDLE std_i = GetStdHandle(STD_INPUT_HANDLE);
     DWORD  mode;
     GetConsoleMode(std_i, &mode);
@@ -302,7 +307,10 @@ void stdio_signal_init(bool signal) {
     SetConsoleMode(std_i, mode);
 }
 
-bool stdio_check_signal() {
+/**
+ * 检查是否有ctrl+c信号
+ */
+bool aFuntool::stdio_check_signal() {
     HANDLE std_i = GetStdHandle(STD_INPUT_HANDLE);
     HANDLE std_o = GetStdHandle(STD_OUTPUT_HANDLE);
     if (std_i == INVALID_HANDLE_VALUE || std_o == INVALID_HANDLE_VALUE) {
@@ -317,7 +325,7 @@ bool stdio_check_signal() {
     return res;
 }
 
-int convertMultiByte(char **dest, const char *str, UINT from, UINT to) {
+int aFuntool::convertMultiByte(char **dest, const char *str, UINT from, UINT to) {
     if (str == nullptr || dest == nullptr)
         return 0;
 
@@ -340,7 +348,7 @@ int convertMultiByte(char **dest, const char *str, UINT from, UINT to) {
     return re;
 }
 
-int convertWideByte(wchar_t **dest, const char *str, UINT from) {
+int aFuntool::convertWideByte(wchar_t **dest, const char *str, UINT from) {
     if (str == nullptr || dest == nullptr)
         return 0;
 
@@ -352,7 +360,7 @@ int convertWideByte(wchar_t **dest, const char *str, UINT from) {
     return MultiByteToWideChar(from, 0, str, -1, *dest, tmp_len);
 }
 
-int convertFromWideByte(char **dest, const wchar_t *str, UINT to) {
+int aFuntool::convertFromWideByte(char **dest, const wchar_t *str, UINT to) {
     if (str == nullptr || dest == nullptr)
         return 0;
 
@@ -364,10 +372,10 @@ int convertFromWideByte(char **dest, const wchar_t *str, UINT to) {
     return WideCharToMultiByte(to, 0, str, -1, *dest, dest_len, nullptr, nullptr);
 }
 
-int fgets_stdin(char **dest, int len) {
+int aFuntool::fgets_stdin(char **dest, int len) {
     int re = 0;
     if (!_isatty(_fileno(stdin))) {
-        *dest = NEW_STR(len);
+        *dest = calloc(len + 1, char);
         re = fgets(*dest, len, stdin) != nullptr;
         if (!re)
             free(*dest);
@@ -381,7 +389,7 @@ int fgets_stdin(char **dest, int len) {
     return re;
 }
 
-int fungetc_stdin(int ch) {
+int aFuntool::fungetc_stdin(int ch) {
     if (!_isatty(_fileno(stdin)))
         return ungetc(ch, stdin);
 
@@ -411,7 +419,7 @@ int fungetc_stdin(int ch) {
  * 有内容则返回true
  * 无内容则返回false
  */
-bool checkStdin() {
+bool aFuntool::checkStdin() {
     HANDLE std_i = GetStdHandle(STD_INPUT_HANDLE);
     HANDLE std_o = GetStdHandle(STD_OUTPUT_HANDLE);
     pthread_mutex_lock(&buffer_mutex);
@@ -422,7 +430,7 @@ bool checkStdin() {
     return true;
 }
 
-int fputs_std_(const char *str, FILE *std) {
+int aFuntool::fputs_std_(const char *str, FILE *std) {
     if (std == nullptr)
         return 0;
 
@@ -439,7 +447,7 @@ int fputs_std_(const char *str, FILE *std) {
     return re;
 }
 
-size_t vprintf_std_(FILE *std, size_t buf_len, const char *format, va_list ap) {
+size_t aFuntool::vprintf_std_(FILE *std, size_t buf_len, const char *format, va_list ap) {
     if (std == nullptr)
         return 0;
 
@@ -457,32 +465,18 @@ size_t vprintf_std_(FILE *std, size_t buf_len, const char *format, va_list ap) {
     return re;
 }
 
-size_t printf_stdout(size_t buf_len, const char *format, ...) {
-    va_list ap;
-    va_start(ap, format);
-    size_t re = vprintf_std_(stdout, buf_len, format, ap);
-    va_end(ap);
-    return re;
-}
-
-size_t printf_stderr(size_t buf_len, const char *format, ...) {
-    va_list ap;
-    va_start(ap, format);
-    size_t re = vprintf_std_(stderr, buf_len, format, ap);
-    va_end(ap);
-    return re;
-}
-
 #else
 #include <unistd.h>
 #include <fcntl.h>
 
-static pthread_mutex_t fcntl_mutex = PTHREAD_MUTEX_INITIALIZER;  // 只有 export 的函数统一处理该互斥锁
+namespace aFuntool {
+    static pthread_mutex_t fcntl_mutex = PTHREAD_MUTEX_INITIALIZER;  // 只有 export 的函数统一处理该互斥锁
+}
 
 // 用于Linux平台的IO函数
 // 默认Linux平台均使用utf-8
 
-int fgets_stdin(char **dest, int len) {
+int aFuntool::fgets_stdin(char **dest, int len) {
     *dest = calloc(len, char);
     if (fgets(*dest, len, stdin) == nullptr)
         return 0;
@@ -496,7 +490,7 @@ int fgets_stdin(char **dest, int len) {
  *
  * 参考自: https://gist.github.com/SuperH-0630/a4190b89d21c349a8d6882ca71453ae6
  */
-bool checkStdin(void) {
+bool aFuntool::checkStdin(void) {
     if (!isatty(fileno(stdin)))
         return true;
     bool re = false;
@@ -518,7 +512,7 @@ bool checkStdin(void) {
     return re;
 }
 
-bool fclear_stdin(void) {
+bool aFuntool::fclear_stdin(void) {
     if (!isatty(fileno(stdin)))
         return true;
 

src/tool/string.cpp

@@ -6,8 +6,18 @@
 #include <cstdlib>
 #include <cstring>
 #include "tool.hpp"
+using namespace aFuntool;
 
-char *charToStr(char ch) {
+#define EQ_STR(str1, str2) (!strcmp((str1), (str2)))
+#define EQ_WSTR(wid1, wid2) (!wcscmp((wid1), (wid2)))
+
+#define NEW_STR(size) calloc((size) + 1, char)
+#define NEW_WSTR(size) calloc((size) + 1, wchar_t)
+
+#define STR_LEN(p) (((p) == NULL) ? 0 : strlen((p)))
+#define WSTR_LEN(p) (((p) == NULL) ? 0 : wcslen((p)))
+
+char *aFuntool::charToStr(char ch) {
     if (ch == NUL)
         return nullptr;
     char *tmp = NEW_STR(1);
@@ -15,7 +25,7 @@ char *charToStr(char ch) {
     return tmp;
 }
 
-char *strCopy(const char *str){
+char *aFuntool::strCopy(const char *str){
     char *tmp = NEW_STR(STR_LEN(str));
     if (str != nullptr)
         strcpy(tmp, str);
@@ -27,7 +37,7 @@ char *strCopy(const char *str){
  * 函数名: strJoin
  * 目标: 拼接两个字符串
  */
-char *strJoin(const char *first, const char *second, bool free_first, bool free_last) {
+char *aFuntool::strJoin(const char *first, const char *second, bool free_first, bool free_last) {
     if (first == nullptr && second == nullptr)
         return nullptr;
     else if (first == nullptr){
@@ -54,33 +64,11 @@ char *strJoin(const char *first, const char *second, bool free_first, bool free_
     return new_str;
 }
 
-/*
- * 函数名: strJoin_
- * 目标: 拼接两个字符串, 比 strJoin 更快
- */
-char *strJoin_(const char *first, const char *second, bool free_first, bool free_last) {
-    char *new_str = NEW_STR(STR_LEN(first) + STR_LEN(second));
-    strcat(new_str, first);
-    if (second != nullptr)
-        strcat(new_str, second);
-
-    if (free_first) {
-        auto free_ = const_cast<char *>(first);
-        free(free_);
-    }
-
-    if (free_last) {
-        auto free_ = const_cast<char *>(first);
-        free(free_);
-    }
-    return new_str;
-}
-
 /*
  * 函数名: convertToWstr
  * 目标: char *转换为wchar_t *
  */
-wchar_t *convertToWstr(const char *str, bool free_old) {
+wchar_t *aFuntool::convertToWstr(const char *str, bool free_old) {
     size_t len = STR_LEN(str);
     auto tmp = NEW_WSTR(len);
     mbstowcs(tmp, str, len);
@@ -96,7 +84,7 @@ wchar_t *convertToWstr(const char *str, bool free_old) {
  * 函数名: convertToStr
  * 目标: wchar_t *转换为char *
  */
-char *convertToStr(const wchar_t *wstr, bool free_old) {
+char *aFuntool::convertToStr(const wchar_t *wstr, bool free_old) {
     size_t len = WSTR_LEN(wstr);
     auto tmp = NEW_STR(len);
     wcstombs(tmp, wstr, len);

src/tool/time.cpp

@@ -6,11 +6,10 @@
 #include <ctime>
 #include "tool.hpp"
 
-/*
- * 函数名: safe_sleep
- * 目标: 等待指定的秒数(ms) 支持小数
+/**
+ * 等待指定的秒数(ms) 支持小数
  */
-void safeSleep(double ms) {
+void aFuntool::safeSleep(double ms) {
     time_t start = clock();
     time_t now;
     time_t d_time;
@@ -21,12 +20,11 @@ void safeSleep(double ms) {
     } while (d_time < ms_t);
 }
 
-/*
- * 函数名: getTime
- * 目标: 格式化输出时间
+/**
+ * 格式化输出时间
  * 注意: 该函数不可以使用log模块
  */
-char *getTime(time_t *t, const char *format) {
+char *aFuntool::getTime(time_t *t, const char *format) {
     time_t tmp;
     if (t == nullptr)
         t = &tmp;
@@ -48,10 +46,40 @@ char *getTime(time_t *t, const char *format) {
         return nullptr;
     return re;
 #else
-    struct tm *lt = nullptr;
-    lt = localtime (t);  // 转为时间结构
+    struct tm *lt = localtime (t);
     char time_str[100];
     strftime(time_str, 100, format, lt);
     return strCopy(time_str);
 #endif
 }
+
+std::string aFuntool::getTime(time_t *t, const std::string &format) {
+    time_t tmp;
+    if (t == nullptr)
+        t = &tmp;
+
+    time (t);  // 获取时间戳
+#ifdef aFunWIN32_NO_CYGWIN
+    struct tm lt{};
+    if (localtime_s(&lt, t) != 0)
+        return "";
+    wchar_t time_str[100];
+    wchar_t *format_ = nullptr;
+    if (convertWideByte(&format_, format.c_str(), CP_UTF8) == 0)
+        return "";
+    wcsftime(time_str, 100, format_, &lt);
+    free(format_);
+
+    char *tmp_ch = nullptr;
+    if (convertFromWideByte(&tmp_ch, time_str, CP_UTF8) == 0)
+        return "";
+#else
+    struct tm *lt = localtime (t);
+    char time_str[100];
+    strftime(time_str, 100, format.c_str(), lt);
+    char *tmp_ch = strCopy(time_str);;
+#endif
+    std::string ret = tmp_ch;
+    free(tmp_ch);
+    return ret;
+}

test/src/CMakeLists.txt

@@ -5,7 +5,7 @@ foreach(src IN LISTS src_list)
     cmake_path(GET src STEM file_name)
     add_executable(${file_name})
     target_sources(${file_name} PRIVATE ${src})
-    target_link_libraries(${file_name} PUBLIC rt-static)  # 链接静态库 (导出所有符号)
+    target_link_libraries(${file_name} PUBLIC tool-static)  # 链接静态库 (导出所有符号)
     set_target_properties(${file_name}
                           PROPERTIES OUTPUT_NAME "test_${file_name}")
     target_compile_definitions(${file_name} PRIVATE IN_CTEST)
@@ -15,22 +15,12 @@ endforeach()
 
 # tool 相关测试
 file(MD5 "${CMAKE_CURRENT_LIST_DIR}/../share/md5.txt" TOOL_MD5_ANS)
-add_new_test(tool_mem COMMAND "$<TARGET_FILE:tool_mem>")
 add_new_test(tool_byte COMMAND "$<TARGET_FILE:tool_byte>")
+add_new_test(tool_mem COMMAND "$<TARGET_FILE:tool_mem>")
 add_new_test(tool_dlc COMMAND "$<TARGET_FILE:tool_byte>" "$<TARGET_FILE:dlc_lib>")
 add_new_test(tool_regex COMMAND "$<TARGET_FILE:tool_regex>")
 add_new_test(tool_md5 COMMAND "$<TARGET_FILE:tool_md5>" "${TOOL_MD5_ANS}" "${CMAKE_CURRENT_LIST_DIR}/../share/md5.txt")
+add_new_test(tool_logger COMMAND "$<TARGET_FILE:tool_logger>")
+add_new_test(tool_exit COMMAND "$<TARGET_FILE:tool_exit>")
+add_new_test(tool_hash COMMAND "$<TARGET_FILE:tool_hash>")
 set_test_label(tool tool_mem tool_byte tool_dlc tool_regex tool_md5)
-
-# core 相关测试
-add_new_test(byte_code COMMAND "$<TARGET_FILE:byte_code>")
-add_new_test(syntactic COMMAND "$<TARGET_FILE:syntactic>")
-set_test_label(io byte_code syntactic)
-
-add_new_test(lexical COMMAND "$<TARGET_FILE:lexical>")
-add_new_test(reader COMMAND "$<TARGET_FILE:reader>")
-set_test_label(parser lexical reader)
-
-add_new_test(env_init COMMAND "$<TARGET_FILE:env_init>")
-add_new_test(run_code COMMAND "$<TARGET_FILE:run_code>")
-set_test_label(run env_init run_code)

test/src/byte_code.cpp

@@ -1,39 +0,0 @@
-#include <cstdlib>
-#include <cstdio>
-#include "aFun.hpp"
-#include "../../src/core/__code.hpp"
-
-int main() {
-    af_Code *bt1 = makeElementCode("data", '$', 0, "Unknown");
-    af_Code *bt2 = makeElementCode("var1", 0, 1, nullptr);
-
-    af_Code *bt3 = makeElementCode("data2", 0, 0, nullptr);
-    af_Code *bt4 = makeElementCode("var2", 0, 1, nullptr);
-
-    pushCode(&bt1, bt2);
-    pushCode(&bt3, bt4);
-
-    af_Code *bt5 = makeBlockCode(parentheses, bt3, 0, 1, nullptr, nullptr);
-    pushCode(&bt2, bt5);
-
-    int re;
-    if((re = writeByteCode(bt1, "test.aub")) != 1) {
-        fprintf(stderr, "Write test.aub error[%d].\n", re);
-        return EXIT_FAILURE;
-    }
-
-    af_Code *get = nullptr;
-    if((re = readByteCode(&get, "test.aub")) != 1) {
-        fprintf(stderr, "Read test.aub error[%d].\n", re);
-        return EXIT_FAILURE;
-    }
-
-    printf("out:\n");
-    printCode(bt1);
-    printf("in:\n");
-    printCode(get);
-    freeAllCode(bt1);
-    freeAllCode(get);
-    return EXIT_SUCCESS;
-}
-

test/src/env_init.cpp

@@ -1,11 +0,0 @@
-#include <cstdio>
-#include "aFun.hpp"
-
-int main() {
-    aFunCoreInit(nullptr);
-
-    af_Environment *env = makeEnvironment(grt_always);
-    enableEnvironment(env);
-    freeEnvironment(env);
-    return 0;
-}