feat: 代码移迁到C++

CMakeLists.txt

@@ -7,12 +7,17 @@ file(READ ${CMAKE_SOURCE_DIR}/version-info aFunDescription)
 project(aFun
         VERSION ${aFunVersion}
         DESCRIPTION ${aFunDescription}
-        LANGUAGES C)
+        LANGUAGES C CXX)
 
 # CMake系统的相关设定
 set(CMAKE_C_STANDARD 11)
 set(C_EXTENSIONS ON)  # 启动编译器拓展
 set(C_STANDARD_REQUIRED OFF)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CXX_EXTENSIONS ON)  # 启动编译器拓展
+set(CXX_STANDARD_REQUIRED OFF)
+
 set(BUILD_SHARED_LIBS OFF)  # 默认编译静态库 (该设定不可被修改)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
 
@@ -32,12 +37,14 @@ if (MSVC)
         message(FATAL_ERROR "The msvc not support utf-8")
     endif()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /utf-8")
+    set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} /utf-8")
 else()
     check_c_compiler_flag("-fexec-charset=UTF-8" utf8_work)
     if (NOT utf8_work)
         message(FATAL_ERROR "The compiler not support utf-8")
     endif()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexec-charset=UTF-8")
+    set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -fexec-charset=UTF-8")
 endif()
 
 # 相关参数

cmake/aFunHeader.cmake

@@ -1,5 +1,6 @@
 include(GenerateExportHeader)
 
+# 导出文件保持使用.h后缀 以供C库使用
 generate_export_header(tool-shared
                        EXPORT_FILE_NAME "${CMAKE_BINARY_DIR}/${INSTALL_INCLUDEDIR}/aFunToolExport.h"  # 导出的位置
                        BASE_NAME "AFUN_TOOL")

deps/fflags

@@ -1 +1 @@
-Subproject commit 762c693649553bde6a1b9c08f29fbb44180448ba
+Subproject commit 4e4f0fcf07fd3faed3b23deb3b8845d3b46e9490

include/aFun.h

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

include/aFun.hpp

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

include/core/aFunCore.h

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

include/core/aFunCore.hpp

@@ -0,0 +1,29 @@
+#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.h

@@ -1,10 +0,0 @@
-#ifndef AFUN_BYTECODE_H
-#define AFUN_BYTECODE_H
-
-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, FilePath path);
-AFUN_CORE_EXPORT int writeByteCode(af_Code *code, FilePath path);
-
-#endif //AFUN_BYTECODE_H

include/core/bytecode.hpp

@@ -0,0 +1,10 @@
+#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.h → include/core/code.hpp

@@ -22,17 +22,17 @@ enum af_BlockType {
 };
 
 /* 代码块 创建与释放 */
-AFUN_CORE_EXPORT af_Code *makeElementCode(char *var, char prefix, FileLine line, FilePath path);
+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, FilePath path, af_Code **next);
+                                        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, FilePath *path);
+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, FilePath path, FILE *file);
+AFUN_CORE_EXPORT bool readAllCode(af_Code **bt, ConstFilePath path, FILE *file);
 
 /* 代码块 属性访问 */
 AFUN_CORE_EXPORT af_Code *getCodeNext(af_Code *bt);

include/core/core_init.h → include/core/core_init.hpp

@@ -2,13 +2,13 @@
 #define AFUN_INIT_H
 #include "aFunCoreExport.h"
 #include <setjmp.h>
-#include "macro.h"
-#include "sig.h"
-#include "tool.h"
+#include "macro.hpp"
+#include "sig.hpp"
+#include "tool.hpp"
 
 typedef struct aFunCoreInitInfo aFunCoreInitInfo;
 struct aFunCoreInitInfo {
-    char *base_dir;
+    const char *base_dir;
 
     bool log_asyn;
     jmp_buf *buf;

include/core/env.h → include/core/env.hpp

@@ -1,7 +1,7 @@
 #ifndef AFUN_ENV
 #define AFUN_ENV
 #include "aFunCoreExport.h"
-#include "tool.h"
+#include "tool.hpp"
 #include "prefix_macro.h"
 
 typedef struct af_Environment af_Environment;
@@ -14,10 +14,10 @@ typedef struct af_GuardianList af_GuardianList, **paf_GuardianList;
 typedef void TopMsgProcessFunc(af_Message *msg, bool is_top, af_Environment *env);
 DEFINE_DLC_SYMBOL(TopMsgProcessFunc);
 
-typedef af_GuardianList *GuardianFunc(char *type, bool is_guard, void *data, af_Environment *env);
+typedef af_GuardianList *GuardianFunc(const char *type, bool is_guard, void *data, af_Environment *env);
 DEFINE_DLC_SYMBOL(GuardianFunc);
 
-typedef void GuardianDestruct(char *type, void *data, af_Environment *env);
+typedef void GuardianDestruct(const char *type, void *data, af_Environment *env);
 DEFINE_DLC_SYMBOL(GuardianDestruct);
 
 enum GcRunTime {
@@ -25,9 +25,9 @@ enum GcRunTime {
     grt_count,  // 累计式运行
 };
 
-#include "code.h"
-#include "object.h"
-#include "var.h"
+#include "code.hpp"
+#include "object.hpp"
+#include "var.hpp"
 
 /* 运行环境 创建与释放 */
 AFUN_CORE_EXPORT af_Environment *makeEnvironment(enum GcRunTime grt);
@@ -36,20 +36,20 @@ AFUN_CORE_EXPORT af_Environment *deriveEnvironment(bool derive_tmp, bool derive_
                                                    af_Environment *base);
 
 /* 消息 创建与释放 */
-AFUN_CORE_EXPORT af_Message *makeMessage(char *type, size_t size);
+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(char *type, char *error, af_Environment *env);
-AFUN_CORE_EXPORT af_Message *makeERRORMessageFormat(char *type, af_Environment *env, const char *format, ...);
-AFUN_CORE_EXPORT af_Message *makeIMPORTMessage(char *mark, 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(char *type, char *error, char *note, FileLine line, FilePath path);
+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(char *mark, af_Object *obj, af_Environment *env);
+af_ImportInfo *makeImportInfo(const char *mark, af_Object *obj, af_Environment *env);
 void freeImportInfo(af_ImportInfo *ii, af_Environment *env);
 
 /* 运行环境 相关操作 */
@@ -67,27 +67,27 @@ AFUN_CORE_EXPORT void waitForEnviromentExit(af_Environment *env);
 
 /* 消息 相关操作 */
 AFUN_CORE_EXPORT void pushMessageUp(af_Message *msg, af_Environment *env);
-AFUN_CORE_EXPORT void *popMessageUpData(char *type, 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(char *type, 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(char *name, char *data, af_Environment *env);
-AFUN_CORE_EXPORT void setEnvVarNumber(char *name, int32_t data, 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(char *type, DLC_SYMBOL(TopMsgProcessFunc) func, af_Environment *env);
+AFUN_CORE_EXPORT bool addTopMsgProcess(const char *type, DLC_SYMBOL(TopMsgProcessFunc) func, af_Environment *env);
 
 /* 顶层消息处理器 相关操作 */
-AFUN_CORE_EXPORT bool addGuardian(char *type, bool always, bool derive, size_t size, DLC_SYMBOL(GuardianFunc) func,
+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(char *type, af_Environment *env);
+AFUN_CORE_EXPORT bool popGuardian(const char *type, af_Environment *env);
 
 /* LiteralRegex 相关操作 */
-AFUN_CORE_EXPORT bool pushLiteralRegex(char *pattern, char *func, bool in_protect, af_Environment *env);
+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);
@@ -95,18 +95,18 @@ 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, char *note, af_ErrorInfo *ei);
+AFUN_CORE_EXPORT void pushErrorBacktracking(FileLine line, FilePath file, const char *note, af_ErrorInfo *ei);
 
 /* GuardianList 相关操作 */
 AFUN_CORE_EXPORT af_GuardianList **pushGuardianList(af_Object *obj, af_Object *func, af_GuardianList **pgl, af_Environment *env);
 
 /* 环境变量 属性访问 */
-AFUN_CORE_EXPORT char *findEnvVarData(char *name, af_Environment *env);
-AFUN_CORE_EXPORT int32_t *findEnvVarNumber(char *name, 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(char *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);

include/core/func.h → include/core/func.hpp

@@ -19,8 +19,8 @@ enum af_FuncInfoEmbedded {
 };
 
 #include "aFunCoreExport.h"
-#include "code.h"
-#include "object.h"
+#include "code.hpp"
+#include "object.hpp"
 
 typedef struct af_CallFuncInfo af_CallFuncInfo;
 struct af_CallFuncInfo {
@@ -48,13 +48,13 @@ AFUN_CORE_EXPORT void freeAllArgCodeList(af_ArgCodeList *acl, af_Environment *en
 /* 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(char *name, af_ArgCodeList *acl, 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(void);
+AFUN_CORE_EXPORT af_FuncBody *makeDynamicFuncBody();
 AFUN_CORE_EXPORT af_FuncBody *freeFuncBody(af_FuncBody *fb);
 AFUN_CORE_EXPORT void freeAllFuncBody(af_FuncBody *fb);
 
@@ -64,10 +64,10 @@ AFUN_CORE_EXPORT af_FuncInfo *makeFuncInfo(enum af_FuncInfoScope scope, enum af_
 AFUN_CORE_EXPORT void freeFuncInfo(af_FuncInfo *fi);
 
 /* af_ArgCodeList 相关操作 */
-AFUN_CORE_EXPORT af_ArgCodeList **pushArgCodeList(af_ArgCodeList **base, af_ArgCodeList *new);
+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);
+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);

include/core/gc.h → include/core/gc.hpp

@@ -1,8 +1,8 @@
 #ifndef AFUN_GC
 #define AFUN_GC
 #include "aFunCoreExport.h"
-#include "object.h"
-#include "var.h"
+#include "object.hpp"
+#include "var.hpp"
 
 typedef uint32_t GcCount;
 typedef struct af_GcList af_GcList;

include/core/global_obj.h

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

include/core/global_obj.hpp

@@ -0,0 +1,7 @@
+#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

@@ -9,11 +9,11 @@
 
 #ifndef AFUN_OBJ_API_H
 #define AFUN_OBJ_API_H
-#include "env.h"
-#include "object.h"
-#include "var.h"
-#include "func.h"
-#include "gc.h"
+#include "env.hpp"
+#include "object.hpp"
+#include "var.hpp"
+#include "func.hpp"
+#include "gc.hpp"
 
 /* 定义一些函数原型 */
 /* API函数 */
@@ -23,8 +23,8 @@ 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(char *type, bool is_guard, void *data, af_Environment *env);
-typedef void GuardianDestruct(char *type, void *data, af_Environment *env);
+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;
@@ -37,7 +37,7 @@ typedef struct af_FuncBody *callFuncBody(af_CallFuncInfo *info, af_Environment *
  * API第三个参数: 通常为void *data [仅与data有关的函数会直接传入该值]
  */
 
-#define BASE_ARG char *id, af_Object *obj /* 基础参数 */
+#define BASE_ARG const char *id, af_Object *obj /* 基础参数 */
 
 /*** Object void *data 管理 ***/
 typedef size_t obj_getDataSize(BASE_ARG);  // 获取data的大小

include/core/info/token.h

@@ -1,6 +1,6 @@
 #ifndef AFUN_TOKEN_H
 #define AFUN_TOKEN_H
-#include "tool.h"
+#include "tool.hpp"
 
 enum af_TokenType {
     TK_ERROR = -1,

include/core/object.h → include/core/object.hpp

@@ -1,7 +1,7 @@
 #ifndef AFUN_OBJECT
 #define AFUN_OBJECT
 #include "aFunCoreExport.h"
-#include "tool.h"
+#include "tool.hpp"
 
 typedef uint32_t ObjAPIUint;
 typedef struct af_Object af_Object;
@@ -12,16 +12,16 @@ typedef struct af_ObjectAPI af_ObjectAPI;
 typedef void objectAPIFunc();
 DEFINE_DLC_SYMBOL(objectAPIFunc);
 
-#include "env.h"
-#include "var.h"
+#include "env.hpp"
+#include "var.hpp"
 
 /* 对象创建 */
-AFUN_CORE_EXPORT af_Object * makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit,
+AFUN_CORE_EXPORT af_Object * makeObject(const char *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(void);
+AFUN_CORE_EXPORT af_ObjectAPI *makeObjectAPI();
 AFUN_CORE_EXPORT void freeObjectAPI(af_ObjectAPI *api);
 
 /* 对象继承表 创建与释放 */
@@ -29,30 +29,30 @@ AFUN_CORE_EXPORT af_Inherit *makeInherit(af_Object *obj);
 AFUN_CORE_EXPORT void freeAllInherit(af_Inherit *ih);
 
 /* 对象 相关操作 */
-AFUN_CORE_EXPORT bool setObjectAttributes(char *name, char p_self, char p_posterity, char p_external, af_Object *attributes,
+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, char *api_name, af_ObjectAPI *api);
-AFUN_CORE_EXPORT int addAPIToObject(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af_Object *obj);
+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);
+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 char *getObjectID(af_Object *obj);
+AFUN_CORE_EXPORT const char *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 void *findAPI(char *api_name, af_ObjectAPI *api);
-AFUN_CORE_EXPORT void *findObjectAPI(char *api_name, af_Object *obj);
+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);
 
 /* 对象继承表 属性访问 */

include/core/parser.h

@@ -1,26 +0,0 @@
-#ifndef AFUN_PARSER_H
-#define AFUN_PARSER_H
-#include "aFunCoreExport.h"
-#include "tool.h"
-#include "token.h"
-#include "reader.h"
-
-#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(FilePath name, char *str, bool free_str);
-AFUN_CORE_EXPORT af_Parser *makeParserByFile(FilePath path);
-AFUN_CORE_EXPORT af_Parser *makeParserByStdin(FilePath file);
-
-/* Parser 相关操作 */
-AFUN_CORE_EXPORT af_Code *parserCode(af_Parser *parser);
-AFUN_CORE_EXPORT void initParser(af_Parser *parser);
-
-#endif //AFUN_PARSER_H

include/core/parser.hpp

@@ -0,0 +1,26 @@
+#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.h → include/core/reader.hpp

@@ -1,6 +1,6 @@
-#ifndef AFUN_READER_H
-#define AFUN_READER_H
-#include "tool.h"
+#ifndef AFUN_READER_HPP
+#define AFUN_READER_HPP
+#include "tool.hpp"
 
 #define READER_MODE_NORMAL (0)
 #define READER_MODE_FINISHED (1)
@@ -12,4 +12,4 @@ DEFINE_DLC_SYMBOL(readerFunc);
 typedef void destructReaderFunc(void *data);
 DEFINE_DLC_SYMBOL(destructReaderFunc);
 
-#endif //AFUN_READER_H
+#endif //AFUN_READER_HPP

include/core/run.h → include/core/run.hpp

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

include/core/sig.h → include/core/sig.hpp

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

include/core/thread.h → include/core/thread.hpp

@@ -1,9 +1,9 @@
-#ifndef AFUN_THREAD_H
-#define AFUN_THREAD_H
+#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_H
+#endif //AFUN_THREAD_HPP

include/core/var.h → include/core/var.hpp

@@ -6,11 +6,13 @@ typedef struct af_VarSpace af_VarSpace;
 typedef struct af_VarList af_VarList;
 
 #include "aFunCoreExport.h"
-#include "tool.h"
-#include "object.h"
+#include "tool.hpp"
+#include "object.hpp"
 
 /* 变量 创建 */
-AFUN_CORE_EXPORT af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_Environment *env);
+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);
@@ -22,14 +24,15 @@ 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, char *id);
+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(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(char *name, af_Object *visitor, af_VarSpace *vs);
-AFUN_CORE_EXPORT bool setVarToVarSpace(char *name, af_Object *obj, af_Object *visitor, af_VarSpace *vs);
+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);
@@ -37,26 +40,28 @@ AFUN_CORE_EXPORT bool setVarSpaceProtect(af_Object *visitor, af_VarSpace *vs, bo
 /* 变量空间链 相关操作 */
 AFUN_CORE_EXPORT bool addVarToVarSpaceList(af_Var *var, af_Object *visitor, af_VarList *vsl,
                                            af_Environment *env);
-AFUN_CORE_EXPORT bool makeVarToVarSpaceList(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(char *name, char p_self, char p_posterity, char p_external, af_Object *obj,
-                                               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(char *name, af_Object *visitor, af_VarList *vsl);
-AFUN_CORE_EXPORT bool setVarToVarList(char *name, af_Object *obj, af_Object *visitor, af_VarList *vsl);
+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, char *id, af_Environment *env);
+AFUN_CORE_EXPORT af_Object *findVarNode(af_Var *var, const char *id, af_Environment *env);
 
 /* 变量空间 属性访问 */
-AFUN_CORE_EXPORT af_Var *findVarFromVarSpace(char *name, af_Object *visitor, af_VarSpace *vs);
+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(char *name, af_Object *visitor, af_VarList *vsl);
+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.h → include/main.hpp

@@ -1,5 +1,5 @@
-#ifndef AFUN_MAIN_H
-#define AFUN_MAIN_H
+#ifndef AFUN_MAIN_HPP
+#define AFUN_MAIN_HPP
 #include "base.h"
 
 #ifdef aFunWIN32_NO_CYGWIN
@@ -13,4 +13,4 @@
 extern char *base_path;
 extern Logger *aFunlangLogger;
 
-#endif //AFUN_MAIN_H
+#endif //AFUN_MAIN_HPP

include/runtime/aFunlang.h → include/runtime/aFunlang.hpp

@@ -1,12 +1,12 @@
-#ifndef AFUN_AFUNLANG_H
-#define AFUN_AFUNLANG_H
+#ifndef AFUN_AFUNLANG_HPP
+#define AFUN_AFUNLANG_HPP
 #include "aFunlangExport.h"
-#include "aFunCore.h"
-#include "runtime.h"
+#include "aFunCore.hpp"
+#include "runtime.hpp"
 
 typedef struct aFunInitInfo aFunInitInfo;
 struct aFunInitInfo {
-    char *base_dir;
+    const char *base_dir;
 
     bool log_asyn;
     jmp_buf *buf;
@@ -19,7 +19,7 @@ struct aFunRunInfo {
 };
 
 AFUN_LANG_EXPORT bool aFunInit(aFunInitInfo *info);
-AFUN_LANG_EXPORT bool aFunDestruct(void);
+AFUN_LANG_EXPORT bool aFunDestruct();
 
 AFUN_LANG_EXPORT void defineRunEnv(aFunRunInfo *run_env);
 AFUN_LANG_EXPORT void undefRunEnv(aFunRunInfo *run_env);
@@ -28,11 +28,11 @@ AFUN_LANG_EXPORT af_Environment *creatAFunEnvironment(int argc, char **argv);
 AFUN_LANG_EXPORT bool destructAFunEnvironment(af_Environment *env);
 
 /* 源文件运行 */
-AFUN_LANG_EXPORT int runCodeFromString(char *code, char *string_name, int mode, 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(char *name, 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_H
+#endif //AFUN_AFUNLANG_HPP

include/runtime/runtime.h → include/runtime/runtime.hpp

@@ -1,9 +1,9 @@
-#ifndef AFUN_RUNTIME_H
-#define AFUN_RUNTIME_H
+#ifndef AFUN_RUNTIME_HPP
+#define AFUN_RUNTIME_HPP
 
 typedef struct APIFuncList APIFuncList;
 struct APIFuncList {
-    char *name;
+    const char *name;
     void *func;  // objectAPIFunc
     DlcHandle *dlc;  // func 的 来源
     DLC_SYMBOL(objectAPIFunc) func_;  // func_和func二选一, func_时dlc无效
@@ -17,7 +17,7 @@ struct InheritDefineList {
 
 typedef struct ObjectDefineList ObjectDefineList;
 struct ObjectDefineList {
-    char *id;
+    const char *id;
 
     bool free_api;
     af_ObjectAPI *api;
@@ -27,7 +27,7 @@ struct ObjectDefineList {
     af_Object *belong;
     af_Inherit *inherit;
 
-    char *var_name;
+    const char *var_name;
     char p_self, p_posterity, p_external;
 
     af_Object **save;  // obj保存位置
@@ -35,14 +35,14 @@ struct ObjectDefineList {
 
 typedef struct LiteralFuncList LiteralFuncList;
 struct LiteralFuncList {
-    char *pattern;
-    char *func;
+    const char *pattern;
+    const char *func;
     bool in_protect;
 };
 
 typedef struct TopMsgFuncList TopMsgFuncList;
 struct TopMsgFuncList {
-    char *type;
+    const char *type;
     TopMsgProcessFunc *func;
     DlcHandle *dlc;  // func 的 来源
     DLC_SYMBOL(TopMsgProcessFunc) func_;  // func_和func二选一, func_时dlc无效
@@ -51,7 +51,7 @@ struct TopMsgFuncList {
 
 typedef struct GuardianFuncList GuardianFuncList;
 struct GuardianFuncList {
-    char *type;
+    const char *type;
     bool always;
     bool derive;
     size_t size;
@@ -69,8 +69,8 @@ struct GuardianFuncList {
     void (*initData)(void *data, af_Environment *env);  // data初始化的函数
 };
 
-AFUN_LANG_EXPORT int runtimeTool(char *name, af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env);
-AFUN_LANG_EXPORT int runtimeToolImport(char *name, af_Object **obj, af_Code **code, af_Environment *env);
+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);
@@ -79,4 +79,4 @@ AFUN_LANG_EXPORT void makeTopMsgProcessFromList(const TopMsgFuncList top_msg_lis
 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_H
+#endif //AFUN_RUNTIME_HPP

include/tool/btye.h → include/tool/btye.hpp

@@ -26,7 +26,7 @@ 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, char *str);
+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);

include/tool/dlc.h → include/tool/dlc.hpp

@@ -1,5 +1,5 @@
-#ifndef AFUN_DLC_H
-#define AFUN_DLC_H
+#ifndef AFUN_DLC_HPP
+#define AFUN_DLC_HPP
 #include "aFunToolExport.h"
 #include "dlfcn.h"  // CMake 处理 dlfcn.h 的位置
 
@@ -20,21 +20,18 @@
  */
 
 #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
+#define NEW_DLC_SYMBOL(TYPE, NAME) typedef struct DLC##NAME##SYMBOL { TYPE *symbol; struct DlcHandle *dlc; } DLC##NAME##SYMBOL, *pDLC##NAME##SYMBOL
+
+typedef struct DlcSymbol_ DlcSymbol_;
+typedef struct DlcHandle DlcHandle;
 
 #define DLC_SYMBOL(NAME) pDLC##NAME##SYMBOL
 #define GET_SYMBOL(SYMBOL) (*((SYMBOL)->symbol))
-#define MAKE_SYMBOL(symbol, TYPE) ((pDLC##TYPE##SYMBOL) (makeSymbol_(NULL, symbol)))
-#define MAKE_SYMBOL_FROM_HANDLE(symbol, handle, TYPE) ((pDLC##TYPE##SYMBOL) (makeSymbol_((handle), 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) != NULL ? (freeSymbol_((DlcSymbol_ *)(symbol)), NULL) : NULL)
-
-typedef struct DlcSymbol_ DlcSymbol_;
-typedef struct DlcHandle DlcHandle;
+#define FREE_SYMBOL(symbol) ((symbol) != nullptr ? (freeSymbol_((DlcSymbol_ *)(symbol)), nullptr) : nullptr)
 
 AFUN_TOOL_EXPORT DlcHandle *openLibary(const char *file, int mode);
 AFUN_TOOL_EXPORT DlcSymbol_ *makeSymbol_(DlcHandle *dlc, void *symbol);
@@ -43,7 +40,7 @@ AFUN_TOOL_EXPORT DlcSymbol_ *getSymbol_(DlcHandle *dlc, const char *name);
 
 AFUN_TOOL_EXPORT void freeSymbol_(DlcSymbol_ *symbol);
 AFUN_TOOL_EXPORT bool freeLibary(DlcHandle *dlc);
-AFUN_TOOL_EXPORT void dlcExit(void);
+AFUN_TOOL_EXPORT void dlcExit();
 
 
-#endif //AFUN_DLC_H
+#endif //AFUN_DLC_HPP

include/tool/exit_.h → include/tool/exit_.hpp

@@ -1,15 +1,15 @@
 #ifndef AFUN_EXIT_H
 #define AFUN_EXIT_H
-#include <stdlib.h>
+#include <cstdlib>
 
 typedef void aFunExitFunc(void *);
 
 #define aFunExitSuccess EXIT_SUCCESS
 #define aFunExitFail EXIT_FAILURE
 
-AFUN_TOOL_EXPORT _Noreturn void aFunExit(int exit_code);
-AFUN_TOOL_EXPORT int aFunTryExitPseudo(void);
-AFUN_TOOL_EXPORT int aFunExitPseudo(void);
+[[ 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);
 

include/tool/file.h

@@ -1,20 +0,0 @@
-#ifndef AFUN_FILE_H
-#define AFUN_FILE_H
-#include "aFunToolExport.h"
-
-/* 文件处理工具 */
-AFUN_TOOL_EXPORT int checkFile(char *path);
-AFUN_TOOL_EXPORT time_t getFileMTime(char *path);
-AFUN_TOOL_EXPORT char *joinPath(char *path, char *name, char *suffix);
-AFUN_TOOL_EXPORT char *getFileName(char *path_1);
-AFUN_TOOL_EXPORT char *getFileNameWithPath(char *path_1);
-AFUN_TOOL_EXPORT char *getFilePath(char *path_1, int dep);
-AFUN_TOOL_EXPORT char *getFileSurfix(char *path);
-AFUN_TOOL_EXPORT char *fileNameToVar(char *name, bool need_free);
-AFUN_TOOL_EXPORT char *findPath(char *path, char *env, bool need_free);
-AFUN_TOOL_EXPORT char *getExedir(int dep);
-AFUN_TOOL_EXPORT uintmax_t getFileSize(char *path);
-AFUN_TOOL_EXPORT bool isCharUTF8(char *str);
-AFUN_TOOL_EXPORT FILE *fileOpen(char *path_, char *mode_);
-AFUN_TOOL_EXPORT int fileClose(FILE *file);
-#endif //AFUN_FILE_H

include/tool/file.hpp

@@ -0,0 +1,20 @@
+#ifndef AFUN_FILE_HPP
+#define AFUN_FILE_HPP
+#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);
+#endif //AFUN_FILE_HPP

include/tool/hash.h

@@ -1,11 +0,0 @@
-#ifndef AFUN_HASH_H
-#define AFUN_HASH_H
-#include "aFunToolExport.h"
-
-/* 哈希工具 */
-typedef long int time33_t;
-
-AFUN_TOOL_EXPORT time33_t time33(char *str);
-AFUN_TOOL_EXPORT time33_t w_time33(wchar_t *str);
-
-#endif //AFUN_HASH_H

include/tool/hash.hpp

@@ -0,0 +1,10 @@
+#ifndef AFUN_HASH_HPP
+#define AFUN_HASH_HPP
+#include "aFunToolExport.h"
+
+/* 哈希工具 */
+typedef long int time33_t;
+
+AFUN_TOOL_EXPORT time33_t time33(const char *str);
+
+#endif //AFUN_HASH_HPP

include/tool/log.h → include/tool/log.hpp

@@ -1,9 +1,9 @@
-#ifndef AFUN_LOG_H
-#define AFUN_LOG_H
-#include <setjmp.h>
+#ifndef AFUN_LOG_HPP
+#define AFUN_LOG_HPP
+#include <csetjmp>
 #include "aFunToolExport.h"
-#include "macro.h"
-#include "log_macro.h"
+#include "macro.hpp"
+#include "log_macro.hpp"
 
 enum LogLevel {
     log_track = 0,
@@ -25,26 +25,40 @@ enum LogFactoryPrintConsole {
 typedef enum LogFactoryPrintConsole LogFactoryPrintConsole;
 
 struct Logger {
-    char *id;
+    const char *id;
     LogLevel level;
     jmp_buf *buf;
 };
 typedef struct Logger Logger;
 
-AFUN_TOOL_EXPORT void printLogSystemInfo(void);
+AFUN_TOOL_EXPORT void printLogSystemInfo();
 AFUN_TOOL_EXPORT int initLogSystem(FilePath path, bool asyn);
-AFUN_TOOL_EXPORT int destructLogSystem(void);
+AFUN_TOOL_EXPORT int destructLogSystem();
 
-AFUN_TOOL_EXPORT void initLogger(Logger *logger, char *id, LogLevel level);
+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, char *file, int line, char *func, char *format, ...);
-AFUN_TOOL_EXPORT int writeDebugLog_(Logger *logger, char *file, int line, char *func, char *format, ...);
-AFUN_TOOL_EXPORT int writeInfoLog_(Logger *logger, char *file, int line, char *func, char *format, ...);
-AFUN_TOOL_EXPORT int writeWarningLog_(Logger *logger, char *file, int line, char *func, char *format, ...);
-AFUN_TOOL_EXPORT int writeErrorLog_(Logger *logger, char *file, int line, char *func, char *format, ...);
-AFUN_TOOL_EXPORT int writeSendErrorLog_(Logger *logger, char *file, int line, char *func, char *format, ...);
-AFUN_TOOL_EXPORT int writeFatalErrorLog_(Logger *logger, char *file, int line, char *func, int exit_code, char *format, ...);
+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__
@@ -53,53 +67,53 @@ AFUN_TOOL_EXPORT int writeFatalErrorLog_(Logger *logger, char *file, int line, c
 #endif
 
 #if aFunWriteTrack
-#define writeTrackLog(logger, ...) writeTrackLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define writeTrackLog(logger, ...) writeTrackLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
 #else
-#define writeTrackLog(logger, ...) (NULL)
+#define writeTrackLog(logger, ...) (nullptr)
 #endif
 
 #if aFunWriteDebug
-#define writeDebugLog(logger, ...) writeDebugLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define writeDebugLog(logger, ...) writeDebugLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
 #define assertDebugLog(c, logger, ...) ((c) || writeDebugLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeDebugLog(logger, ...) (NULL)
+#define writeDebugLog(logger, ...) (nullptr)
 #define assertDebugLog(c, logger, ...) (c)
 #endif
 
 #if aFunWriteInfo
-#define writeInfoLog(logger, ...) writeInfoLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define writeInfoLog(logger, ...) writeInfoLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
 #define assertInfoLog(c, logger, ...) ((c) || writeInfoLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeInfoLog(logger, ...) (NULL)
+#define writeInfoLog(logger, ...) (nullptr)
 #define assertInfoLog(c, logger, ...) (c)
 #endif
 
 #if !aFunIgnoreWarning
-#define writeWarningLog(logger, ...) writeWarningLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define writeWarningLog(logger, ...) writeWarningLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
 #define assertWarningLog(c, logger, ...) ((c) || writeWarningLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeWarningLog(logger, ...) (NULL)
+#define writeWarningLog(logger, ...) (nullptr)
 #define assertWarningLog(c, logger, ...) (c)
 #endif
 
 #if !aFunIgnoreError
-#define writeErrorLog(logger, ...) writeErrorLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
+#define writeErrorLog(logger, ...) writeErrorLog_(logger, file_line, __FUNCTION__, __VA_ARGS__)
 #define assertErrorLog(c, logger, ...) ((c) || writeErrorLog(logger, "Assert " #c " error : " __VA_ARGS__))
 #else
-#define writeErrorLog(logger, ...) (NULL)
+#define writeErrorLog(logger, ...) (nullptr)
 #define assertErrorLog(c, logger, ...) (c)
 #endif
 
 #if !aFunOFFAllLog
-#define writeSendErrorLog(logger, ...) writeSendErrorLog_(logger, file_line, (char *)__FUNCTION__, __VA_ARGS__)
-#define writeFatalErrorLog(logger, exit_code, ...) writeFatalErrorLog_(logger, file_line, (char *)__FUNCTION__, exit_code, __VA_ARGS__)
+#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__))
 #else
-#define writeSendErrorLog(logger, ...) (NULL)
-#define writeFatalErrorLog(logger, exit_code, ...) (NULL)
+#define writeSendErrorLog(logger, ...) (nullptr)
+#define writeFatalErrorLog(logger, exit_code, ...) (nullptr)
 #define assertSendErrorLog(c, logger, ...) (c)
 #define assertFatalErrorLog(c, logger, exit_code, ...) (c)
 #endif
 
-#endif //AFUN_LOG_H
+#endif //AFUN_LOG_HPP

include/tool/log_macro.h → include/tool/log_macro.hpp

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

include/tool/macro.h → include/tool/macro.hpp

@@ -3,8 +3,8 @@
  * 目标: 定义公共宏 和 公共头文件
  */
 
-#ifndef AFUN_MACRO_H
-#define AFUN_MACRO_H
+#ifndef AFUN_MACRO_HPP
+#define AFUN_MACRO_HPP
 #include <stdbool.h>
 #include <inttypes.h>
 #include <stdarg.h>
@@ -21,5 +21,6 @@
 
 typedef uint32_t FileLine;  // 文件行号
 typedef char *FilePath;  // 文件路径
+typedef const char *ConstFilePath;  // 文件路径
 
-#endif //AFUN_MACRO_H
+#endif //AFUN_MACRO_HPP

include/tool/md5.h → include/tool/md5.hpp

@@ -1,5 +1,5 @@
-#ifndef AFUN_MD5_H
-#define AFUN_MD5_H
+#ifndef AFUN_MD5_HPP
+#define AFUN_MD5_HPP
 #include "aFunToolExport.h"
 
 /* md5计算工具 */
@@ -15,4 +15,4 @@ 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);
 
-#endif //AFUN_MD5_H
+#endif //AFUN_MD5_HPP

include/tool/mem.h

@@ -1,28 +0,0 @@
-/*
- * 文件名: mem.h
- * 目标: 内存管理工具的头文件
- */
-
-#ifndef AFUN_MEM_H
-#define AFUN_MEM_H
-
-#include <stdlib.h>
-#include "log.h"
-#define free(p) ((((p)!=NULL) ? (free(p), NULL) : NULL), (p)=NULL)  // 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 == NULL)
-        writeFatalErrorLog(NULL, EXIT_FAILURE, "The memory error");
-    return re;
-}
-
-#define calloc_bak(n, size) (safeCalloc(n, size))  /* 备份 */
-#define calloc calloc_bak
-
-#endif
-#endif  // AFUN_MEM_H

include/tool/mem.hpp

@@ -0,0 +1,28 @@
+/*
+ * 文件名: mem.h
+ * 目标: 内存管理工具的头文件
+ */
+
+#ifndef AFUN_MEM_HPP
+#define AFUN_MEM_HPP
+
+#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;
+}
+
+#define calloc(n, obj) (obj *)(safeCalloc(n, sizeof(obj)))
+#define calloc_size(n, size) (safeCalloc(n, size))
+
+#endif
+#endif  // AFUN_MEM_HPP

include/tool/path.h → include/tool/path.hpp

@@ -1,5 +1,5 @@
-#ifndef AFUN_PATH_H
-#define AFUN_PATH_H
+#ifndef AFUN_PATH_HPP
+#define AFUN_PATH_HPP
 #include "base.h"
 
 /* 路径工具 */
@@ -23,4 +23,4 @@
 
 #define EXE_SUFFIX aFunExeSuffix
 
-#endif //AFUN_PATH_H
+#endif //AFUN_PATH_HPP

include/tool/regex.h → include/tool/regex.hpp

@@ -7,8 +7,8 @@
 
 typedef struct af_Regex af_Regex;
 
-AFUN_TOOL_EXPORT af_Regex *makeRegex(char *pattern, char **error);
+AFUN_TOOL_EXPORT af_Regex *makeRegex(const char *pattern, char **error);
 AFUN_TOOL_EXPORT void freeRegex(af_Regex *rg);
-AFUN_TOOL_EXPORT int matchRegex(char *subject, af_Regex *rg, char **error);
+AFUN_TOOL_EXPORT int matchRegex(const char *subject, af_Regex *rg, char **error);
 
 #endif //AFUN_REGEX

include/tool/stdio_.h → include/tool/stdio_.hpp

@@ -1,11 +1,11 @@
 #ifndef AFUN_STDIO__H
 #define AFUN_STDIO__H
-#include <stdio.h>
+#include <cstdio>
 #include "base.h"
 
 AFUN_TOOL_EXPORT int fgets_stdin(char **dest, int len);
-AFUN_TOOL_EXPORT bool checkStdin(void);
-AFUN_TOOL_EXPORT bool fclear_stdin(void);
+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))))
@@ -13,7 +13,7 @@ AFUN_TOOL_EXPORT bool fclear_stdin(void);
 #ifdef aFunWIN32_NO_CYGWIN
 
 AFUN_TOOL_EXPORT void stdio_signal_init(bool signal);
-AFUN_TOOL_EXPORT bool stdio_check_signal(void);
+AFUN_TOOL_EXPORT bool stdio_check_signal();
 
 #ifdef _MSC_VER
 #pragma warning(disable : 5105)  // 关闭 5105 的警告输出 (Windows.h中使用)
@@ -22,26 +22,26 @@ AFUN_TOOL_EXPORT bool stdio_check_signal(void);
 #include <io.h>
 #include <Windows.h>
 
-AFUN_TOOL_EXPORT int convertMultiByte(char **dest, char *str, UINT from, UINT to);  // win32 特有函数
-AFUN_TOOL_EXPORT int convertWideByte(wchar_t **dest, char *str, UINT from);  // win32 特有函数
-AFUN_TOOL_EXPORT int convertFromWideByte(char **dest, wchar_t *str, UINT to);
+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(void);
+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_(char *str, FILE *std);
+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)
 
 
-AFUN_TOOL_EXPORT size_t vprintf_std_(FILE *std, size_t buf_len, char *format, va_list ap);
+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)
 
 
-AFUN_TOOL_EXPORT size_t printf_stdout(size_t buf_len, char *format, ...);
-AFUN_TOOL_EXPORT size_t printf_stderr(size_t buf_len, char *format, ...);
+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, ...);
 
 #else
 #define fgetc_stdin() fgetc(stdin)

include/tool/str.h

@@ -1,31 +0,0 @@
-#ifndef AFUN_STR_H
-#define AFUN_STR_H
-#include <wchar.h>
-#include <string.h>
-#include "aFunToolExport.h"
-
-/* 字符串工具 */
-#define EQ_STR(str1, str2) (!strcmp((str1), (str2)))
-#define EQ_WSTR(wid1, wid2) (!wcscmp((wid1), (wid2)))
-
-#define pathCopy(path) ((FilePath)strCopy((char *)(path)))
-
-#define NEW_STR(size) (char *)calloc((size) + 1, sizeof(char))
-#define NEW_WSTR(size) (wchar_t *)calloc((size) + 1, sizeof(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 wchar_t *wstrCopy(const wchar_t *str);
-AFUN_TOOL_EXPORT wchar_t *wstrExpansion(wchar_t *str, size_t size, bool free_old);
-AFUN_TOOL_EXPORT char *strJoin(char *first, char *second, bool free_first, bool free_last);
-AFUN_TOOL_EXPORT char *strJoin_(char *first, char *second, bool free_first, bool free_last);
-AFUN_TOOL_EXPORT wchar_t *wstrJoin(wchar_t *first, wchar_t *second, bool free_first, bool free_last);
-AFUN_TOOL_EXPORT wchar_t *wstrJoin_(wchar_t *first, wchar_t *second, bool free_first, bool free_last);
-AFUN_TOOL_EXPORT wchar_t *wstrCopySelf(wchar_t *str, long times);
-AFUN_TOOL_EXPORT wchar_t *wstrReverse(wchar_t *str);
-AFUN_TOOL_EXPORT wchar_t *convertToWstr(char *str, bool free_old);
-AFUN_TOOL_EXPORT char *convertToStr(wchar_t *wstr, bool free_old);
-
-#endif //AFUN_STR_H

include/tool/str.hpp

@@ -0,0 +1,24 @@
+#ifndef AFUN_STR_HPP
+#define AFUN_STR_HPP
+#include <cwchar>
+#include <cstring>
+#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);
+
+#endif //AFUN_STR_HPP

include/tool/time_s.h → include/tool/time_s.hpp

@@ -4,5 +4,5 @@
 
 /* 时间工具 */
 AFUN_TOOL_EXPORT void safeSleep(double ms);
-AFUN_TOOL_EXPORT char *getTime(time_t *t, char *format);
+AFUN_TOOL_EXPORT char *getTime(time_t *t, const char *format);
 #endif //AFUN_TIME_H

include/tool/tool.h

@@ -1,31 +0,0 @@
-/*
- * 文件名: tool.h
- * 目标: aFun tool公共API
- * aFunTool是aFun实用工具库, 内含aFun调用的实用函数
- */
-
-#ifndef AFUN_TOOL_H
-#define AFUN_TOOL_H
-
-#include "mem.h"
-#include "macro.h"
-#include "aFunToolExport.h"
-
-#include "stdio_.h"
-#include "exit_.h"
-#include "btye.h"
-#include "dlc.h"
-#include "file.h"
-#include "hash.h"
-#include "md5.h"
-#include "path.h"
-#include "regex.h"
-#include "str.h"
-#include "time_s.h"
-#include "log.h"
-
-#include "fflags.h"
-#include "pthread.h"
-#include "aFun_ht.h"
-
-#endif //AFUN_TOOL_H

include/tool/tool.hpp

@@ -0,0 +1,34 @@
+/*
+ * 文件名: tool.h
+ * 目标: aFun tool公共API
+ * aFunTool是aFun实用工具库, 内含aFun调用的实用函数
+ */
+
+#ifndef AFUN_TOOL_HPP
+#define AFUN_TOOL_HPP
+
+#include "mem.hpp"
+#include "macro.hpp"
+#include "aFunToolExport.h"
+
+#include "stdio_.hpp"
+#include "exit_.hpp"
+#include "btye.hpp"
+#include "dlc.hpp"
+#include "file.hpp"
+#include "hash.hpp"
+#include "md5.hpp"
+#include "path.hpp"
+#include "regex.hpp"
+#include "str.hpp"
+#include "time_s.hpp"
+#include "log.hpp"
+
+#include "pthread.h"
+#include "fflags.h"
+
+extern "C"{
+    #include "aFun_ht.h"
+}
+
+#endif //AFUN_TOOL_HPP

lang/hgt.py

@@ -77,7 +77,7 @@ def getFileFromPath(paths: List[str], file_type_: List[str]) -> FileList:
 
 
 # 获取宏 HT_aFunGetText的列表并计算
-file_list: FileList = getFileFromPath(input_dir, ['.c', '.h'])
+file_list: FileList = getFileFromPath(input_dir, ['.c', '.cpp', '.h', '.hpp'])
 pattern = re.compile(f'HT_{base_name}GetText' + r'\(([\S]+),[\s]*(\"[^\"]*\")\)')  # 宏的定义
 flat_list: FlatList = {}
 for file in file_list:

src/CMakeLists.txt

@@ -30,15 +30,15 @@ add_subdirectory(runtime)  # runtime 依赖 core
 # source在子目录中被使用, 为了避免子目录访问到source, 子目录将在此前面被执行
 file(GLOB source
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.c)
+     ${CMAKE_CURRENT_LIST_DIR}/*.cpp)
 
 file(GLOB private_h
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.h)
+     ${CMAKE_CURRENT_LIST_DIR}/*.hpp)
 
 file(GLOB include_h
      LIST_DIRECTORIES FALSE
-     "${PROJECT_SOURCE_DIR}/include/*.h")
+     "${PROJECT_SOURCE_DIR}/include/*.hpp")
 
 add_executable(aFun-xx "")  # xx表示均为动态链接
 add_executable(aFun-ct "")  # ct表示均静态链接

src/core/CMakeLists.txt

@@ -1,15 +1,15 @@
 file(GLOB source
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.c)
+     ${CMAKE_CURRENT_LIST_DIR}/*.cpp)
 
 file(GLOB private_h
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.h)
+     ${CMAKE_CURRENT_LIST_DIR}/*.hpp)
 
 file(GLOB public_h
      LIST_DIRECTORIES FALSE
      RELATIVE "${build_include_core}"
-     "${build_include_core}/*.h")
+     "${build_include_core}/*.hpp")
 
 file(GLOB public_h_info
      LIST_DIRECTORIES FALSE

src/core/__code.h → src/core/__code.hpp

@@ -5,8 +5,8 @@
 
 #ifndef AFUN_BYTECODE_H_
 #define AFUN_BYTECODE_H_
-#include "tool.h"
-#include "code.h"
+#include "tool.hpp"
+#include "code.hpp"
 
 struct af_Code {  // 一个 Code 的结构体
     enum af_CodeType type;
@@ -24,7 +24,7 @@ struct af_Code {  // 一个 Code 的结构体
     };
 
     FileLine line;
-    FilePath path;  // path == NULL表示沿用上层地址
+    FilePath path;  // path == nullptr表示沿用上层地址
 
     struct af_Code *prev;
     struct af_Code *next;

src/core/__env.h → src/core/__env.hpp

@@ -1,6 +1,6 @@
 #ifndef AFUN_ENV_H_
 #define AFUN_ENV_H_
-#include "tool.h"
+#include "tool.hpp"
 #include "pthread.h"
 
 typedef struct af_Activity af_Activity;
@@ -14,13 +14,13 @@ typedef struct af_LiteralRegex af_LiteralRegex;
 typedef struct af_ErrorBacktracking af_ErrorBacktracking;
 typedef struct af_EnvironmentList af_EnvironmentList;
 
-#include "env.h"
-#include "__object.h"
-#include "__var.h"
-#include "__code.h"
-#include "__gc.h"
-#include "__func.h"
-#include "__monitor.h"
+#include "env.hpp"
+#include "__object.hpp"
+#include "__var.hpp"
+#include "__code.hpp"
+#include "__gc.hpp"
+#include "__func.hpp"
+#include "__monitor.hpp"
 #include "regex.h"
 
 #define DEFAULT_GC_COUNT_MAX (50)
@@ -45,15 +45,23 @@ struct af_GuardianList {
     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 {
-        act_top = 0,  /* 顶层 永远存在第一层 */
-        act_func,  /* 函数调用 */
-        act_top_import,  /* 导入 运算结束后global进入msg反 */
-        act_guardian,  /* 守护器 */
-    } type;
+    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 锁】
@@ -79,11 +87,7 @@ struct af_Activity {  // 活动记录器
         };
 
         struct {  // gc以外的其他内容使用
-            enum af_ActivityStatus {
-                act_func_get = 0,
-                act_func_arg,
-                act_func_normal,
-            } status;
+            enum af_ActivityStatus status;
 
             struct af_Object *func;  // 函数本身
 
@@ -93,7 +97,7 @@ struct af_Activity {  // 活动记录器
 
             struct af_VarList *func_varlist;  // 函数内部变量空间 (运行函数体时会设置为 主变量空间)
 
-            struct af_Code *bt_top;  // 最顶层设置为NULL, 函数调用设置为block, (bt_start的上一个元素) [只在函数调用的非NORMAL期有用]
+            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]
@@ -164,10 +168,10 @@ struct af_ActivityTrackBack {
 typedef void TopMsgProcessFunc(af_Message *msg, bool is_top, af_Environment *env);
 NEW_DLC_SYMBOL(TopMsgProcessFunc, TopMsgProcessFunc);
 
-typedef af_GuardianList *GuardianFunc(char *type, bool is_guard, void *data, af_Environment *env);
+typedef af_GuardianList *GuardianFunc(const char *type, bool is_guard, void *data, af_Environment *env);
 NEW_DLC_SYMBOL(GuardianFunc, GuardianFunc);
 
-typedef void GuardianDestruct(char *type, void *data, af_Environment *env);
+typedef void GuardianDestruct(const char *type, void *data, af_Environment *env);
 NEW_DLC_SYMBOL(GuardianDestruct, GuardianDestruct);
 
 struct af_TopMsgProcess {  // 顶层msg处理器
@@ -207,6 +211,15 @@ struct af_EnvironmentList {
     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;  // 监视器线程
 
@@ -220,14 +233,7 @@ struct af_Environment {  // 运行环境
     bool son_exit;  // 由线程外部控制, 命令线程结束
     pthread_mutex_t thread_lock;  // 保护 father_exit 和 son_exit 和 son_count
 
-    enum af_CoreStatus {
-        core_creat = 0,
-        core_init,  // 执行初始化程序
-        core_normal,  // 正常执行
-        core_normal_gc,  // 正常执行
-        core_stop,  // 当前运算退出
-        core_exit,  // 解释器退出
-    } status;
+    enum af_CoreStatus status;
     pthread_mutex_t status_lock;
 
     /* 保护空间 */
@@ -298,9 +304,9 @@ AFUN_CORE_NO_EXPORT void popActivity(bool is_normal, af_Message *msg, af_Environ
 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, char *data, 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, char *mark, 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);
@@ -316,7 +322,7 @@ 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(char *literal, char **func, bool *in_protect, 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);
@@ -328,11 +334,11 @@ 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_(char *name, int32_t data, af_Environment *env);
-AFUN_CORE_NO_EXPORT af_EnvVar *setEnvVarData_(char *name, char *data, af_Environment *env);
+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, af_GuardianList **base);
+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);

src/core/__func.h → src/core/__func.hpp

@@ -1,10 +1,10 @@
 #ifndef AFUN_FUNC_H_
 #define AFUN_FUNC_H_
-#include "tool.h"
+#include "tool.hpp"
 
-#include "func.h"
-#include "__object.h"
-#include "__code.h"
+#include "func.hpp"
+#include "__object.hpp"
+#include "__code.hpp"
 
 struct af_ArgCodeList {
     void *info;  // info信息
@@ -24,13 +24,15 @@ struct af_ArgList {
     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 {
-        func_body_c = 0,  // 回调C函数
-        func_body_code,  // 执行af_Code
-        func_body_import,  // import内容
-        func_body_dynamic,
-    } type;
+    enum af_FuncBodyType type;
 
     union {
         DLC_SYMBOL(callFuncBody) c_func;
@@ -58,7 +60,7 @@ struct af_FuncInfo {
 };
 
 /* FuncInfo 相关操作 */
-AFUN_CORE_NO_EXPORT bool pushDynamicFuncBody(af_FuncBody *new, af_FuncBody *body);
+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);

src/core/__gc.h → src/core/__gc.hpp

@@ -1,6 +1,6 @@
 #ifndef AFUN_GC_H_
 #define AFUN_GC_H_
-#include "tool.h"
+#include "tool.hpp"
 #include "pthread.h"
 
 typedef struct GC_Var GC_Var;
@@ -44,8 +44,8 @@ struct GC_VarSpace {
 
 #undef GC_CHAIN
 
-#include "__env.h"  // 这部分内容依赖上面的定义
-#include "gc.h"
+#include "__env.hpp"  // 这部分内容依赖上面的定义
+#include "gc.hpp"
 
 struct af_GcList {
     enum af_GcListType type;

src/core/__global_obj.h → src/core/__global_obj.hpp

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

src/core/__monitor.h → src/core/__monitor.hpp

@@ -1,7 +1,7 @@
-#ifndef AFUN___MONITOR_H
-#define AFUN___MONITOR_H
+#ifndef AFUN___MONITOR_HPP
+#define AFUN___MONITOR_HPP
 #include "pthread.h"
-#include "macro.h"
+#include "macro.hpp"
 
 typedef struct af_Monitor af_Monitor;
 struct af_Monitor {
@@ -13,8 +13,8 @@ struct af_Monitor {
 };
 
 
-#include "__env.h"
+#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_H
+#endif //AFUN___MONITOR_HPP

src/core/__object.h → src/core/__object.hpp

@@ -5,15 +5,15 @@
 
 #ifndef AFUN_OBJECT_H_
 #define AFUN_OBJECT_H_
-#include "tool.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.h"
-#include "__gc.h"
+#include "object.hpp"
+#include "__gc.hpp"
 #include "pthread.h"
 
 #define API_HASHTABLE_SIZE (8)
@@ -43,7 +43,7 @@ struct af_ObjectData {
     bool allow_inherit;  // 是否允许被继承
     bool free_api;  // 是否释放api
 
-    struct af_Inherit *inherit;  // 只有顶级继承对象的inherit属性可为NULL
+    struct af_Inherit *inherit;  // 只有顶级继承对象的inherit属性可为nullptr
     bool free_inherit;  // 是否释放inherit
 
     struct af_VarSpace *var_space;
@@ -55,7 +55,7 @@ struct af_ObjectData {
 };
 
 struct af_Object {
-    struct af_Object *belong;  // 只有顶级属对象的belong属性可为NULL
+    struct af_Object *belong;  // 只有顶级属对象的belong属性可为nullptr
     struct af_ObjectData *data;
     pthread_rwlock_t lock;  // 保护上面两个字段
 
@@ -73,7 +73,7 @@ struct af_Inherit {
 AFUN_CORE_NO_EXPORT void freeObject(af_Object *obj, af_Environment *env);
 
 /* ObjectData 属性访问 */
-AFUN_CORE_NO_EXPORT af_Object *findObjectAttributesByObjectData(char *name, af_Object *visitor, af_ObjectData *od,
+AFUN_CORE_NO_EXPORT af_Object *findObjectAttributesByObjectData(const char *name, af_Object *visitor, af_ObjectData *od,
                                                                 af_Environment *env);
 
 /* ObjectData 释放函数 */

src/core/__parser.h → src/core/__parser.hpp

@@ -1,9 +1,9 @@
 #ifndef AFUN_PARSER_H_
 #define AFUN_PARSER_H_
 #include <stdio.h>
-#include "__reader.h"
+#include "__reader.hpp"
 #include "token.h"
-#include "parser.h"
+#include "parser.hpp"
 
 enum af_LexicalStatus {
     lex_begin = 0,  // 起始类型

src/core/__reader.h → src/core/__reader.hpp

@@ -2,8 +2,8 @@
 #define AFUN_READER_H_
 #include <stdio.h>
 #include "aFunCoreExport.h"  // reader.h 不包含 aFunCoreExport.h
-#include "tool.h"
-#include "reader.h"
+#include "tool.hpp"
+#include "reader.hpp"
 
 #define DEFAULT_BUF_SIZE (1024)
 #define NEW_BUF_SIZE (512)
@@ -34,9 +34,9 @@ struct af_Reader {
 };
 
 /* Reader 创建与释放 */
-AFUN_CORE_NO_EXPORT af_Reader *
-makeReader(FileLine line, FilePath file, DLC_SYMBOL(readerFunc) read_func, DLC_SYMBOL(destructReaderFunc) destruct_func,
-           size_t data_size);
+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 初始化函数 */

src/core/__run.h → src/core/__run.hpp

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

src/core/__sig.h

@@ -1,5 +0,0 @@
-#ifndef AFUN___SIG_H_
-#define AFUN___SIG_H_
-#include <signal.h>
-#include "sig.h"
-#endif //AFUN___SIG_H_

src/core/__sig.hpp

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

src/core/__var.h → src/core/__var.hpp

@@ -1,19 +1,19 @@
 #ifndef AFUN_VAR_H_
 #define AFUN_VAR_H_
-#include "macro.h"
+#include "macro.hpp"
 #include "pthread.h"
 
 // 这些typedef可能会被下面include的文件使用
 typedef struct af_VarNode af_VarNode;
 typedef struct af_VarCup af_VarCup;
 
-#include "var.h"
-#include "__gc.h"
+#include "var.hpp"
+#include "__gc.hpp"
 
 #define VAR_HASHTABLE_SIZE (8)
 
 struct af_VarNode {
-    char *id;  // 变量存储值的id为NULL
+    char *id;  // 变量存储值的id为nullptr
     struct af_Object *obj;
     struct af_VarNode *next;
 };

src/core/bytecode.c → src/core/bytecode.cpp

@@ -1,5 +1,5 @@
-#include "aFunCore.h"
-#include "tool.h"
+#include "aFunCore.hpp"
+#include "tool.hpp"
 
 #define HEAD "aFun-BytecodeFile"
 #define Done(write) do{if(!(write)){re = 0; goto RETURN_;}}while(0)
@@ -13,7 +13,7 @@ static bool checkVersion(uint32_t major, uint32_t minor, uint32_t patch) {
 
 char const * const writeByteCodeError[5] = {
         "File write error.",  // 0
-        NULL,  // 无错误
+        nullptr,  // 无错误
         "File open error.",  // 2
         "Code md5 error.",  // 3
         "Write code error."  // 4
@@ -21,7 +21,7 @@ char const * const writeByteCodeError[5] = {
 
 char const * const readByteCodeError[7] = {
         "File read error.",  // 0
-        NULL,  // 无错误
+        nullptr,  // 无错误
         "File open error.",  // 2
         "The file is not an aFun Bytecode file.",  // 3
         "Incompatible version.",  // 4
@@ -29,17 +29,17 @@ char const * const readByteCodeError[7] = {
         "Code is broken."  // 6
 };
 
-int writeByteCode(af_Code *code, FilePath path) {
-    if (code == NULL || path == NULL)
+int writeByteCode(af_Code *code, ConstFilePath path) {
+    if (code == nullptr || path == nullptr)
         return 0;
 
     char *md5 = getCodeMD5(code);
-    if (md5 == NULL)
+    if (md5 == nullptr)
         return 3;
 
     int re = 1;
     FILE *file = fileOpen(path, "wb");
-    if (file == NULL) {
+    if (file == nullptr) {
         re = 2;
         goto RETURN_2;
     }
@@ -61,21 +61,21 @@ RETURN_2:
     return re;
 }
 
-int readByteCode(af_Code **code, FilePath path) {
-    if (code == NULL || path == NULL || *code != NULL)
+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 == NULL)
+    if (file == nullptr)
         return 2;
 
-    char *head = NULL;
+    char *head = nullptr;
     uint32_t major = 0;
     uint32_t minor = 0;
     uint32_t patch = 0;
-    char *md5str = NULL;
-    char *code_md5 = NULL;
+    char *md5str = nullptr;
+    char *code_md5 = nullptr;
 
     Done(byteReadStr(file, &head));
     if (!EQ_STR(head, HEAD)) {
@@ -99,7 +99,7 @@ int readByteCode(af_Code **code, FilePath path) {
     }
 
     code_md5 = getCodeMD5(*code);
-    if (code_md5 == NULL || !EQ_STR(code_md5, md5str)) {
+    if (code_md5 == nullptr || !EQ_STR(code_md5, md5str)) {
         re = 6;
         freeAllCode(*code);
         goto RETURN_;

src/core/code.c → src/core/code.cpp

@@ -3,14 +3,14 @@
  * 目标: 管理Code结构体的函数
  */
 
-#include <stdio.h>
-#include <ctype.h>
-#include "aFunCore.h"
-#include "tool.h"
-#include "__code.h"
+#include <cstdio>
+#include <cctype>
+#include "aFunCore.hpp"
+#include "tool.hpp"
+#include "__code.hpp"
 
 /* Code 创建函数 */
-static af_Code *makeCode(char prefix, FileLine line, FilePath path);
+static af_Code *makeCode(char prefix, FileLine line, ConstFilePath path);
 static af_Code *freeCode(af_Code *bt);
 
 /* Code 相关操作 */
@@ -29,21 +29,21 @@ 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, FilePath path) {
-    af_Code *bt = calloc(1, sizeof(af_Code));
+static af_Code *makeCode(char prefix, FileLine line, ConstFilePath path) {
+    auto bt = calloc(1, af_Code);
     bt->line = line;
     bt->prefix = prefix;
-    if (path != NULL)
-        bt->path = pathCopy(path);
+    if (path != nullptr)
+        bt->path = strCopy(path);
     return bt;
 }
 
-af_Code *makeElementCode(char *var, char prefix, FileLine line, FilePath path) {
-    if (prefix != NUL && strchr(E_PREFIX, prefix) == NULL)
+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 NULL;
+        return nullptr;
 
     af_Code *bt = makeCode(prefix, line, path);
     bt->type = code_element;
@@ -64,11 +64,11 @@ af_Code *makeElementCode(char *var, char prefix, FileLine line, FilePath path) {
  */
 static int countElement(af_Code *element, CodeUInt *elements, af_Code **next) {
     CodeUInt layer = 0;  // layer 是相对于当前element的层级数, 可能为负数
-    af_Code *tmp = NULL;
-    if (next == NULL)
+    af_Code *tmp = nullptr;
+    if (next == nullptr)
         next = &tmp;
 
-    for (*elements = 0; element != NULL; *next = element, element = element->next) {
+    for (*elements = 0; element != nullptr; *next = element, element = element->next) {
         if (layer == 0)
             (*elements)++;
 
@@ -87,21 +87,20 @@ static int countElement(af_Code *element, CodeUInt *elements, af_Code **next) {
         return 0;
 }
 
-af_Code *makeBlockCode(enum af_BlockType type, af_Code *element, char prefix, FileLine line, FilePath path, af_Code **next) {
-    af_Code *bt = NULL;
-    af_Code *tmp = NULL;  // 保存最后一个code的地址
+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 == NULL)
+    if (next == nullptr)
         next = &tmp;
 
-    if (prefix != NUL && strchr(B_PREFIX, prefix) == NULL)
+    if (prefix != NUL && strchr(B_PREFIX, prefix) == nullptr)
         prefix = NUL;
 
     if (countElement(element, &elements, next) != 1)
-        return NULL;
+        return nullptr;
 
-    bt = makeCode(prefix, line, path);
+    af_Code *bt = makeCode(prefix, line, path);
     bt->type = code_block;
     bt->block.type = type;
     bt->next = element;
@@ -113,26 +112,26 @@ af_Code *makeBlockCode(enum af_BlockType type, af_Code *element, char prefix, Fi
 }
 
 af_Code *pushCode(af_Code **base, af_Code *next) {
-    af_Code *prev = NULL;
-    while ((*base) != NULL) {
+    af_Code *prev = nullptr;
+    while ((*base) != nullptr) {
         prev = *base;
         base = &(prev->next);
     }
     next->prev = prev;
     *base = next;
 
-    while (next != NULL && next->next != NULL)
+    while (next != nullptr && next->next != nullptr)
         next = next->next;
 
     return next;
 }
 
-af_Code *copyAllCode(af_Code *base, FilePath *path) {
-    af_Code *dest = NULL;
+af_Code *copyAllCode(af_Code *base, ConstFilePath path) {
+    af_Code *dest = nullptr;
     af_Code **pdest = &dest;
-    af_Code *prev = NULL;
+    af_Code *prev = nullptr;
 
-    for (NULL; base != NULL; base = base->next, prev = *pdest, pdest = &(prev->next)) {
+    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;
@@ -151,9 +150,9 @@ af_Code *copyAllCode(af_Code *base, FilePath *path) {
         }
     }
 
-    if (dest != NULL && path != NULL) {
+    if (dest != nullptr && path != nullptr) {
         free(dest->path);
-        dest->path = pathCopy(path);
+        dest->path = strCopy(path);
     }
 
     return dest;
@@ -164,12 +163,12 @@ af_Code *copyAllCode(af_Code *base, FilePath *path) {
  * 目标: 拷贝 code, 并为末尾的code设置合适的code_end
  */
 af_Code *copyCode(af_Code *base){
-    af_Code *dest = NULL;
+    af_Code *dest = nullptr;
     af_Code **pdest = &dest;
-    af_Code *prev = NULL;
+    af_Code *prev = nullptr;
 
     CodeUInt layer = 0;
-    for (NULL; base != NULL; base = base->next, prev = *pdest, pdest = &(prev->next)) {
+    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;
@@ -216,33 +215,33 @@ static af_Code *freeCode(af_Code *bt) {
 }
 
 void freeAllCode(af_Code *bt) {
-    while (bt != NULL)
+    while (bt != nullptr)
         bt = freeCode(bt);
 }
 
 af_Code *getCodeNext(af_Code *bt) {
     if (!LAYER_ADD1(bt))
-        return bt->code_end == 0 ? bt->next : NULL;
+        return bt->code_end == 0 ? bt->next : nullptr;
 
     CodeUInt layer = 1;
     bt = bt->next;  // 跳过第一个code_block
-    while (bt != NULL) {
+    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 NULL;
+            return nullptr;
         layer = layer - bt->code_end;
         bt = bt->next;
     }
 
-    return NULL;
+    return nullptr;
 }
 
 af_Code *getCodeElement(af_Code *bt) {
     if (!LAYER_ADD1(bt))
-        return NULL;
+        return nullptr;
     return bt->next;
 }
 
@@ -273,20 +272,20 @@ static bool writeCode(af_Code *bt, FILE *file) {
  * 备注: 写入字节码时不做语义检查, 在读取时最语义检查即可
  */
 bool writeAllCode(af_Code *bt, FILE *file) {
-    if (bt == NULL || bt->path == NULL)
+    if (bt == nullptr || bt->path == nullptr)
         return false;
 
     if (!codeSemanticCheck(bt))
         goto RETURN_FALSE;
 
-    for (NULL; bt != NULL; bt = bt->next) {
+    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 == NULL)));  // 记录是否为最后一位
+        Done(byteWriteUint_8(file, (bt->next == nullptr)));  // 记录是否为最后一位
     }
 
     return true;
@@ -306,8 +305,8 @@ static bool readCode(af_Code **bt, af_Code *prev, FILE *file) {
     Done(byteReadUint_32(file,&line));
     Done(byteReadUint_32(file, &code_end));
 
-    *bt = makeCode((char)prefix, line, NULL);
-    (*bt)->type = type;
+    *bt = makeCode((char)prefix, line, nullptr);
+    (*bt)->type = (enum af_CodeType)type;
     (*bt)->code_end = (CodeUInt)code_end;
     (*bt)->prev = prev;
 
@@ -320,7 +319,7 @@ static bool readCode(af_Code **bt, af_Code *prev, FILE *file) {
             uint8_t is_empty;
             Done(byteReadUint_8(file, &block_type));
             Done(byteReadUint_8(file,&is_empty));
-            (*bt)->block.type = block_type;
+            (*bt)->block.type = (enum af_BlockType)block_type;
             (*bt)->block.is_empty = (CodeUInt)is_empty;
             break;
         }
@@ -330,12 +329,12 @@ static bool readCode(af_Code **bt, af_Code *prev, FILE *file) {
     return true;
 }
 
-bool readAllCode(af_Code **bt, FilePath path, FILE *file) {
+bool readAllCode(af_Code **bt, ConstFilePath path, FILE *file) {
     af_Code **base = bt;
-    af_Code *prev = NULL;
-    *bt = NULL;
+    af_Code *prev = nullptr;
+    *bt = nullptr;
 
-    for (NULL; true;prev = *bt, bt = &(prev->next)) {
+    for(NULL; true;prev = *bt, bt = &(prev->next)) {
         if(!readCode(bt, prev, file))
             goto RETURN_FALSE;
         if (CLEAR_FERROR(stdin))
@@ -347,7 +346,7 @@ bool readAllCode(af_Code **bt, FilePath path, FILE *file) {
             break;
     }
 
-    if (*base != NULL && path != NULL)
+    if (*base != nullptr && path != nullptr)
         (*base)->path = strCopy(path);
 
     if (!codeSemanticCheck(*base))
@@ -356,7 +355,7 @@ bool readAllCode(af_Code **bt, FilePath path, FILE *file) {
 
 RETURN_FALSE:
     freeAllCode(*bt);
-    *bt = NULL;
+    *bt = nullptr;
     return false;
 }
 
@@ -420,10 +419,10 @@ static char *codeToStr_(af_Code *code, LayerInt *layer, struct af_BlockEnd **bn)
             default:
                 break;
         }
-        struct af_BlockEnd *new = calloc(1, sizeof(struct af_BlockEnd));
-        new->ch = ch;
-        new->next = *bn;
-        *bn = new;
+        auto new_bn = calloc(1, struct af_BlockEnd);
+        new_bn->ch = ch;
+        new_bn->next = *bn;
+        *bn = new_bn;
         (*layer)++;
     }
     return re;
@@ -436,7 +435,7 @@ static char *codeToStr_(af_Code *code, LayerInt *layer, struct af_BlockEnd **bn)
 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 == NULL)
+        if (*bn == nullptr)
             break;
         (*layer)--;
         re[i] = (*bn)->ch;
@@ -454,11 +453,11 @@ static char *codeEndToStr(CodeUInt code_end, LayerInt *layer, struct af_BlockEnd
  * 目标: 转换n个元素(或n个函数调用)为code
  */
 char *codeToStr(af_Code *code, int n) {
-    char *re = strCopy(NULL);
-    struct af_BlockEnd *bn = NULL;
+    char *re = strCopy(nullptr);
+    struct af_BlockEnd *bn = nullptr;
     LayerInt layer = 0;
 
-    for (NULL; code != NULL && layer >= 0 && (n > 0 || n == -1); code = code->next) {
+    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;
@@ -480,7 +479,7 @@ static void printLayerSpace(size_t layer) {
 
 void printCode(af_Code *bt) {
     size_t layer = 0;
-    for (NULL; bt != NULL || layer < 0; bt = bt->next) {
+    for(NULL; bt != nullptr || layer < 0; bt = bt->next) {
         printLayerSpace(layer);
         layer = layer - bt->code_end;
         switch (bt->type) {
@@ -505,7 +504,7 @@ enum af_CodeType getCodeType(af_Code *code) {
 
 enum af_BlockType getCodeBlockType(af_Code *code) {
     if (code->type != code_block)
-        return '(';
+        return (enum af_BlockType)'(';
     return code->block.type;
 }
 
@@ -519,7 +518,7 @@ CodeUInt getCodeEndCount(af_Code *code) {
 
 char *getCodeElementData(af_Code *code) {
     if (code->type != code_element)
-        return NULL;
+        return nullptr;
     return code->element.data;
 }
 
@@ -528,19 +527,19 @@ CodeUInt getCodeElementCount(af_Code *code) {
         return 0;
 
     CodeUInt count;
-    if (countElement(code->next, &count, NULL) == 0)
+    if (countElement(code->next, &count, nullptr) == 0)
         return 0;
     return count;
 }
 
 char *getCodeMD5(af_Code *code) {
-    char *md5str = calloc(MD5_STR_LEN + 1, sizeof(char));
+    char *md5str = calloc(MD5_STR_LEN + 1, char);
     char md5_value[MD5_SIZE];
     MD5_CTX *md5 = MD5Init();
 
-    for (NULL; code != NULL; code = code->next) {
-        char *tmp = NULL;
-        char head[] = {code->type, code->prefix, 'x', 'x', NUL};
+    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)
@@ -566,7 +565,7 @@ char *getCodeMD5(af_Code *code) {
 }
 
 static bool codeElementCheck(char *data) {
-    if (data == NULL)
+    if (data == nullptr)
         return false;
 
     return isCharUTF8(data);
@@ -578,10 +577,10 @@ static bool codeElementCheck(char *data) {
  */
 bool codeSemanticCheck(af_Code *code) {
     CodeUInt layer = 0;
-    if (code == NULL || code->path == NULL)
+    if (code == nullptr || code->path == nullptr)
         return false;
 
-    for (NULL; code != NULL; code = code->next) {
+    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))

src/core/core_init.c → src/core/core_init.cpp

@@ -3,17 +3,17 @@
  * 目标: 初始化函数
  */
 
-#include "core_init.h"
-#include "__sig.h"
-#include "tool.h"
-#include <locale.h>
+#include <clocale>
+#include "core_init.hpp"
+#include "__sig.hpp"
+#include "tool.hpp"
 
 static Logger aFunCoreLogger_;
 Logger *aFunCoreLogger = &aFunCoreLogger_;
 
-char *log_path = NULL;
-char *lang_path = NULL;
-char *varlib_path = NULL;
+char *log_path = nullptr;
+char *lang_path = nullptr;
+char *varlib_path = nullptr;
 
 static void destructCoreExit(void *data) {
     free(log_path);
@@ -22,24 +22,24 @@ static void destructCoreExit(void *data) {
 }
 
 bool aFunCoreInit(aFunCoreInitInfo *info) {
-    if (info == NULL) {
+    if (info == nullptr) {
         static aFunCoreInitInfo info_default = {.base_dir=".",
-                                                .buf=NULL,
                                                 .log_asyn=true,
+                                                .buf=nullptr,
                                                 .level=log_info};
         info = &info_default;
     }
 
     getEndian();
-    if (setlocale(LC_ALL, "") == NULL)
+    if (setlocale(LC_ALL, "") == nullptr)
         return false;
-    if (info->base_dir == NULL)
+    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, NULL);
+    aFunAtExit(destructCoreExit, nullptr);
 
     char *log = strJoin(log_path, "aFunlang", false, false);
     bool re = initLogSystem(log, info->log_asyn);
@@ -58,7 +58,7 @@ bool aFunCoreInit(aFunCoreInitInfo *info) {
     snprintf(LANG_path, 218, "%sLANG", lang_path);
 
     FILE *LANG_file = fileOpen(LANG_path, "r");
-    if (LANG_file != NULL) {
+    if (LANG_file != nullptr) {
         char LANG[100] = {0};
         fgets(LANG, 100, LANG_file);
         if (LANG[strlen(LANG) - 1] == '\n')
@@ -73,12 +73,12 @@ bool aFunCoreInit(aFunCoreInitInfo *info) {
             writeDebugLog(aFunCoreLogger, "aFunCore lang init failed: %s", LANG_lib);
         fileClose(LANG_file);
     } else
-        HT_initaFunGetText(NULL);
+        HT_initaFunGetText(nullptr);
     writeDebugLog(aFunCoreLogger, "aFunCore init success");
     return true;
 }
 
-bool aFunCoreDestruct(void) {
+bool aFunCoreDestruct() {
     destructLogSystem();
     return true;
 }

src/core/func.c → src/core/func.cpp

@@ -1,4 +1,4 @@
-#include "__func.h"
+#include "__func.hpp"
 
 /* FuncBody 创建与释放 */
 static af_FuncBody *makeFuncBody(enum af_FuncBodyType type, char **msg_type);
@@ -7,8 +7,8 @@ static af_FuncBody *makeFuncBody(enum af_FuncBodyType type, char **msg_type);
 static void freeMsgType(char **msg_type);
 
 af_ArgCodeList *makeArgCodeList(af_Code *code, size_t size, bool free_code, bool run_in_func) {
-    af_ArgCodeList *acl = calloc(1, sizeof(af_ArgCodeList));
-    acl->info = calloc(1, size);
+    auto acl = calloc(1, af_ArgCodeList);
+    acl->info = calloc_size(1, size);
     acl->size = size;
     acl->code = code;
     acl->free_code = free_code;
@@ -21,23 +21,23 @@ static af_ArgCodeList *freeArgCodeList(af_ArgCodeList *acl, af_Environment *env)
     free(acl->info);
     if (acl->free_code)
         freeAllCode(acl->code);
-    if (acl->result != NULL)
+    if (acl->result != nullptr)
         gc_delObjectReference(acl->result, env);
     free(acl);
     return next;
 }
 
 void freeAllArgCodeList(af_ArgCodeList *acl, af_Environment *env){
-    while (acl != NULL)
+    while (acl != nullptr)
         acl = freeArgCodeList(acl, env);
 }
 
-af_ArgCodeList **pushArgCodeList(af_ArgCodeList **base, af_ArgCodeList *new) {
-    while (*base != NULL)
+af_ArgCodeList **pushArgCodeList(af_ArgCodeList **base, af_ArgCodeList *new_acl) {
+    while (*base != nullptr)
         base = &((*base)->next);
-    *base = new;
+    *base = new_acl;
 
-    while (*base != NULL)
+    while (*base != nullptr)
         base = &((*base)->next);
     return base;
 }
@@ -50,8 +50,8 @@ af_Object *getArgCodeListResult(af_ArgCodeList *acl) {
     return acl->result;
 }
 
-af_ArgList *makeArgList(char *name, af_Object *obj){
-    af_ArgList *arg_list = calloc(1, sizeof(af_ArgList));
+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;
@@ -60,23 +60,23 @@ af_ArgList *makeArgList(char *name, af_Object *obj){
 static af_ArgList *freeArgList(af_ArgList *al, af_Environment *env){
     af_ArgList *next = al->next;
     free(al->name);
-    if (al->obj != NULL)
+    if (al->obj != nullptr)
         gc_delObjectReference(al->obj, env);
     free(al);
     return next;
 }
 
 void freeAllArgList(af_ArgList *al, af_Environment *env){
-    while (al != NULL)
+    while (al != nullptr)
         al = freeArgList(al, env);
 }
 
-af_ArgList **pushArgList(af_ArgList **base, af_ArgList *new) {
-    while (*base != NULL)
+af_ArgList **pushArgList(af_ArgList **base, af_ArgList *new_al) {
+    while (*base != nullptr)
         base = &((*base)->next);
-    *base = new;
+    *base = new_al;
 
-    while (*base != NULL)
+    while (*base != nullptr)
         base = &((*base)->next);
     return base;
 }
@@ -88,7 +88,7 @@ af_ArgList **pushArgList(af_ArgList **base, af_ArgList *new) {
  * @param env 运行环境
  * @return
  */
-af_ArgList *makeArgListFromArgCodeList(char *name, af_ArgCodeList *acl, af_Environment *env) {
+af_ArgList *makeArgListFromArgCodeList(const char *name, af_ArgCodeList *acl, af_Environment *env) {
     af_Object *obj = getArgCodeListResult(acl);
     gc_addObjectReference(obj, env);
 
@@ -97,7 +97,7 @@ af_ArgList *makeArgListFromArgCodeList(char *name, af_ArgCodeList *acl, af_Envir
 }
 
 bool runArgList(af_ArgList *al, af_VarList *vsl, af_Environment *env){
-    for (NULL; al != NULL; al = al->next) {
+    for(NULL; al != nullptr; al = al->next) {
         if (!makeVarToVarSpaceList(al->name, 3, 3, 3, al->obj, vsl,
                                    env->activity->belong, env))
             return false;
@@ -106,7 +106,7 @@ bool runArgList(af_ArgList *al, af_VarList *vsl, af_Environment *env){
 }
 
 static af_FuncBody *makeFuncBody(enum af_FuncBodyType type, char **msg_type) {
-    af_FuncBody *fb = calloc(1, sizeof(af_FuncBody));
+    auto fb = calloc(1, af_FuncBody);
     fb->type = type;
     fb->msg_type = msg_type;
     return fb;
@@ -126,8 +126,8 @@ af_FuncBody *makeImportFuncBody(af_Code *code, bool free_code, char **msg_type)
     return fb;
 }
 
-af_FuncBody *makeDynamicFuncBody(void) {
-    af_FuncBody *fb = makeFuncBody(func_body_dynamic, NULL);
+af_FuncBody *makeDynamicFuncBody() {
+    af_FuncBody *fb = makeFuncBody(func_body_dynamic, nullptr);
     return fb;
 }
 
@@ -138,7 +138,7 @@ af_FuncBody *makeCFuncBody(DLC_SYMBOL(callFuncBody) c_func, char **msg_type) {
 }
 
 static void freeMsgType(char **msg_type) {
-    for (char *tmp = *msg_type; tmp != NULL; tmp++)
+    for (char *tmp = *msg_type; tmp != nullptr; tmp++)
         free(tmp);
     free(msg_type);
 }
@@ -150,25 +150,25 @@ af_FuncBody *freeFuncBody(af_FuncBody *fb) {
     else if (fb->type == func_body_c)
         FREE_SYMBOL(fb->c_func);
 
-    if (fb->msg_type != NULL)
+    if (fb->msg_type != nullptr)
         freeMsgType(fb->msg_type);
     free(fb);
     return next;
 }
 
 void freeAllFuncBody(af_FuncBody *fb) {
-    while (fb != NULL)
+    while (fb != nullptr)
         fb = freeFuncBody(fb);
 }
 
 void pushFuncBody(af_FuncBody **base, af_FuncBody *body) {
-    while (*base != NULL)
+    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){
-    af_FuncInfo *fi = calloc(1, sizeof(af_FuncInfo));
+    auto fi = calloc(1, af_FuncInfo);
     fi->scope = scope;
     fi->embedded = embedded;
     fi->is_macro = is_macro;
@@ -206,20 +206,20 @@ af_FuncBody *makeDynamicFuncBodyToFuncInfo(af_FuncInfo *fi) {
     return fb;
 }
 
-bool pushDynamicFuncBody(af_FuncBody *new, af_FuncBody *body) {
-    if (body == NULL || body->next == NULL || body->next->type != func_body_dynamic) {
-        freeAllFuncBody(new);
+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 == NULL) {
+    if (new_fub == nullptr) {
         body->next = freeFuncBody(body->next);  // 不添加任何新内容, 但释放func_body_dynamic
     } else {
-        af_FuncBody **next = &new;
-        while ((*next) != NULL)
+        af_FuncBody **next = &new_fub;
+        while ((*next) != nullptr)
             next = &((*next)->next);
-        *next = freeFuncBody(body->next);  // 把func_body_dynamic后的内容添加到new的末尾
-        body->next = new;
+        *next = freeFuncBody(body->next);  // 把func_body_dynamic后的内容添加到new_fub的末尾
+        body->next = new_fub;
     }
 
     return true;

src/core/gc.c → src/core/gc.cpp

@@ -1,5 +1,5 @@
-#include "aFunCore.h"
-#include "__object.h"
+#include "aFunCore.hpp"
+#include "__object.hpp"
 #include "pthread.h"
 
 static void resetGC(af_Environment *env);
@@ -10,8 +10,8 @@ void gc_addObjectData(af_ObjectData *od, af_Environment *base){
 
     pthread_mutex_lock(&base->gc_factory->mutex);
     od->gc.info.reference = 1;
-    od->gc.prev = ((void *) 0);
-    if (base->gc_factory->gc_ObjectData != ((void *) 0))
+    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;
@@ -22,11 +22,11 @@ void gc_delObjectData(af_ObjectData *od, af_Environment *base){
     base = base->base;  // 转换为主线程 Env
 
     pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((od)->gc.prev != ((void *) 0))
+    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 != ((void *) 0))
+    if ((od)->gc.next != nullptr)
         (od)->gc.next->gc.prev = (od)->gc.prev;
     pthread_mutex_unlock(&base->gc_factory->mutex);
 }
@@ -52,8 +52,8 @@ void gc_addObject(af_Object *obj, af_Environment *base){
 
     pthread_mutex_lock(&base->gc_factory->mutex);
     obj->gc.info.reference = 1;
-    obj->gc.prev = ((void *) 0);
-    if (base->gc_factory->gc_Object != ((void *) 0))
+    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;
@@ -64,11 +64,11 @@ void gc_delObject(af_Object *obj, af_Environment *base){
     base = base->base;  // 转换为主线程 Env
 
     pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((obj)->gc.prev != ((void *) 0))
+    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 != ((void *) 0))
+    if ((obj)->gc.next != nullptr)
         (obj)->gc.next->gc.prev = (obj)->gc.prev;
     pthread_mutex_unlock(&base->gc_factory->mutex);
 }
@@ -94,8 +94,8 @@ void gc_addVar(af_Var *var, af_Environment *base) {
 
     pthread_mutex_lock(&base->gc_factory->mutex);
     var->gc.info.reference = 1;
-    var->gc.prev = ((void *) 0);
-    if (base->gc_factory->gc_Var != ((void *) 0))
+    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;
@@ -106,11 +106,11 @@ void gc_delVar(af_Var *var, af_Environment *base){
     base = base->base;  // 转换为主线程 Env
 
     pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((var)->gc.prev != ((void *) 0))
+    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 != ((void *) 0))
+    if ((var)->gc.next != nullptr)
         (var)->gc.next->gc.prev = (var)->gc.prev;
     pthread_mutex_unlock(&base->gc_factory->mutex);
 }
@@ -143,8 +143,8 @@ void gc_addVarSpace(af_VarSpace *vs, af_Environment *base){
 
     pthread_mutex_lock(&base->gc_factory->mutex);
     vs->gc.info.reference = 1;
-    vs->gc.prev = ((void *) 0);
-    if (base->gc_factory->gc_VarSpace != ((void *) 0))
+    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;
@@ -155,12 +155,12 @@ void gc_delVarSpace(af_VarSpace *vs, af_Environment *base){
     base = base->base;  // 转换为主线程 Env
 
     pthread_mutex_lock(&base->gc_factory->mutex);
-    if ((vs)->gc.prev != ((void *) 0))
+    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 != ((void *) 0))
+    if ((vs)->gc.next != nullptr)
         (vs)->gc.next->gc.prev = (vs)->gc.prev;
     pthread_mutex_unlock(&base->gc_factory->mutex);
 }
@@ -186,8 +186,8 @@ void gc_delVarListReference(af_VarList *vsl, af_Environment *base) {
 }
 
 /* gc_Factory 函数 */
-gc_Factory *makegGcFactory(void) {
-    gc_Factory *factory = calloc(1, sizeof(gc_Factory));
+gc_Factory *makegGcFactory() {
+    auto factory = calloc(1, gc_Factory);
 
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
@@ -208,10 +208,10 @@ void freeGcFactory(struct gc_Factory *factory) {
 static af_GcList *freeGcList(af_GcList *gl);
 
 af_GcList *makeGcList(enum af_GcListType type, void *data) {
-    af_GcList *gl = calloc(1, sizeof(af_GcList));
+    auto gl = calloc(1, af_GcList);
     gl->type = type;
     gl->data = data;
-    assertWarningLog(data != NULL, aFunCoreLogger, "GcList not data write.");
+    assertWarningLog(data != nullptr, aFunCoreLogger, "GcList not data write.");
     return gl;
 }
 
@@ -222,7 +222,7 @@ static af_GcList *freeGcList(af_GcList *gl) {
 }
 
 void freeAllGcList(af_GcList *gl) {
-    while (gl != NULL)
+    while (gl != nullptr)
         gl = freeGcList(gl);
 }
 
@@ -243,7 +243,7 @@ static pgc_Analyzed makeAnalyzed(struct af_Object *obj, pgc_Analyzed plist) {
     if (obj->gc.info.reachable)
         return plist;
 
-    *plist = calloc(1, sizeof(gc_Analyzed));
+    *plist = calloc(1, gc_Analyzed);
     (*plist)->obj = obj;
     return &((*plist)->next);
 }
@@ -255,7 +255,7 @@ static gc_Analyzed *freeAnalyzed(gc_Analyzed *base) {
 }
 
 static void freeAllAnalyzed(gc_Analyzed *base) {
-    while (base != NULL)
+    while (base != nullptr)
         base = freeAnalyzed(base);
 }
 
@@ -282,7 +282,7 @@ static pgc_Analyzed checkAnalyzed(gc_Analyzed *analyzed, pgc_Analyzed plist);
 // VarSpace和Var的调用是确定的, 他们不会往回调用除Object外的其他量
 // 所以gc_Analyzed记录Object就足够了
 static pgc_Analyzed reachableObject(struct af_Object *obj, pgc_Analyzed plist) {
-    for (NULL; obj != NULL && !obj->gc.info.reachable; obj = obj->belong) {
+    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)
@@ -303,7 +303,7 @@ static pgc_Analyzed reachableObjectData(struct af_ObjectData *od, pgc_Analyzed p
     if (!od->base->gc.info.reachable)
         plist = makeAnalyzed(od->base, plist);
 
-    for (af_Inherit *ih = od->inherit; ih != NULL; ih = getInheritNext(ih)) {
+    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)
@@ -313,11 +313,11 @@ static pgc_Analyzed reachableObjectData(struct af_ObjectData *od, pgc_Analyzed p
             plist = reachableVarSpace(vs, plist);
     }
 
-    obj_getGcList *func = findAPI("obj_getGcList", od->api);
-    if (func != NULL) {
+    auto func = (obj_getGcList *)findAPI("obj_getGcList", od->api);
+    if (func != nullptr) {
         af_GcList *gl = func(od->id, od->base, od->data);
-        for (af_GcList *tmp = gl; tmp != NULL; tmp = tmp->next) {
-            if (tmp->data == NULL)
+        for (af_GcList *tmp = gl; tmp != nullptr; tmp = tmp->next) {
+            if (tmp->data == nullptr)
                 continue;
 
             switch (tmp->type) {
@@ -352,11 +352,11 @@ static pgc_Analyzed reachableVarSpace(struct af_VarSpace *vs, pgc_Analyzed plist
     vs->gc.info.reachable = true;
 
     pthread_rwlock_rdlock(&vs->lock);
-    if (vs->belong != NULL)
+    if (vs->belong != nullptr)
         plist = makeAnalyzed(vs->belong, plist);
 
     for (int i = 0; i < VAR_HASHTABLE_SIZE; i++) {
-        for (af_VarCup *var = vs->var[i]; var != NULL; var = var->next)
+        for (af_VarCup *var = vs->var[i]; var != nullptr; var = var->next)
             plist = reachableVar(var->var, plist);
     }
 
@@ -371,7 +371,7 @@ static pgc_Analyzed reachableVar(struct af_Var *var, pgc_Analyzed plist) {
     var->gc.info.reachable = true;
 
     pthread_rwlock_rdlock(&var->lock);
-    for (af_VarNode *vn = var->vn; vn != NULL; vn = vn->next) {
+    for (af_VarNode *vn = var->vn; vn != nullptr; vn = vn->next) {
         if (!vn->obj->gc.info.reachable)
             plist = makeAnalyzed(vn->obj, plist);
     }
@@ -380,7 +380,7 @@ static pgc_Analyzed reachableVar(struct af_Var *var, pgc_Analyzed plist) {
 }
 
 static pgc_Analyzed reachableVarSpaceList(struct af_VarList *vsl, pgc_Analyzed plist) {
-    for (NULL; vsl != NULL; vsl = vsl->next) {
+    for(NULL; vsl != nullptr; vsl = vsl->next) {
         if (!vsl->vs->gc.info.reachable)
             plist = reachableVarSpace(vsl->vs, plist);
     }
@@ -389,25 +389,25 @@ static pgc_Analyzed reachableVarSpaceList(struct af_VarList *vsl, pgc_Analyzed p
 
 static pgc_Analyzed iterLinker(af_Environment *env, pgc_Analyzed plist) {
     plist = reachableVarSpace(env->protect, plist);
-    if (env->global != NULL)
+    if (env->global != nullptr)
         plist = reachableObject(env->global, plist);
 
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
+    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)
             plist = reachableObjectData(od, plist);
     }
 
-    for (af_Object *obj = env->gc_factory->gc_Object; obj != NULL; obj = obj->gc.next) {
+    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)
             plist = reachableObject(obj, plist);
     }
 
-    for (af_VarSpace *vs = env->gc_factory->gc_VarSpace; vs != NULL; vs = vs->gc.next) {
+    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)
             plist = reachableVarSpace(vs, plist);
     }
 
-    for (af_Var *var = env->gc_factory->gc_Var; var != NULL; var = var->gc.next) {
+    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)
             plist = reachableVar(var, plist);
     }
@@ -416,7 +416,7 @@ static pgc_Analyzed iterLinker(af_Environment *env, pgc_Analyzed plist) {
 
 static pgc_Analyzed iterEnvironment(af_Environment *env, pgc_Analyzed plist) {
     pthread_mutex_lock(&env->thread_lock);
-    if (env->result != NULL)
+    if (env->result != nullptr)
         plist = reachableObject(env->result, plist);
     pthread_mutex_unlock(&env->thread_lock);
 
@@ -425,27 +425,27 @@ static pgc_Analyzed iterEnvironment(af_Environment *env, pgc_Analyzed plist) {
 }
 
 static pgc_Analyzed reachable(af_Activity *activity, pgc_Analyzed plist) {
-    for (NULL; activity != NULL; activity = activity->prev) {
-        if (activity->belong != NULL)
+    for(NULL; activity != nullptr; activity = activity->prev) {
+        if (activity->belong != nullptr)
             plist = reachableObject(activity->belong, plist);
 
         plist = reachableVarSpaceList(activity->run_varlist, plist);
 
         if (activity->type == act_guardian) {  // gc不执行接下来的检查
-            for (af_GuardianList *gl = activity->gl; gl != NULL; gl = gl->next) {
+            for (af_GuardianList *gl = activity->gl; gl != nullptr; gl = gl->next) {
                 plist = reachableObject(gl->func, plist);
-                if (gl->obj != NULL)
+                if (gl->obj != nullptr)
                     plist = reachableObject(gl->obj, plist);
             }
         } else {
 
-            if (activity->func != NULL)
+            if (activity->func != nullptr)
                 plist = reachableObject(activity->func, plist);
 
-            if (activity->return_obj != NULL)
+            if (activity->return_obj != nullptr)
                 plist = reachableObject(activity->return_obj, plist);
 
-            if (activity->parentheses_call != NULL)
+            if (activity->parentheses_call != nullptr)
                 plist = reachableObject(activity->parentheses_call, plist);
 
         plist = reachableVarSpaceList(activity->out_varlist, plist);
@@ -457,22 +457,22 @@ static pgc_Analyzed reachable(af_Activity *activity, pgc_Analyzed plist) {
 }
 
 static pgc_Analyzed checkAnalyzed(gc_Analyzed *analyzed, pgc_Analyzed plist) {
-    for (gc_Analyzed *done = analyzed; done != NULL; done = done->next)
+    for (gc_Analyzed *done = analyzed; done != nullptr; done = done->next)
         plist = reachableObject(done->obj, plist);
     return plist;
 }
 
 static void resetGC(af_Environment *env) {
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next)
+    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 != NULL; obj = obj->gc.next)
+    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 != NULL; vs = vs->gc.next)
+    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 != NULL; var = var->gc.next)
+    for (af_Var *var = env->gc_factory->gc_Var; var != nullptr; var = var->gc.next)
         var->gc.info.reachable = false;
 }
 
@@ -482,7 +482,7 @@ static void resetGC(af_Environment *env) {
  * @param env
  */
 static void freeValue(af_Environment *env) {
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData, *next; od != NULL; od = next) {
+    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);
@@ -490,7 +490,7 @@ static void freeValue(af_Environment *env) {
         }
     }
 
-    for (af_Object *obj = env->gc_factory->gc_Object, *next; obj != NULL; obj = next) {
+    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);
@@ -498,7 +498,7 @@ static void freeValue(af_Environment *env) {
         }
     }
 
-    for (af_VarSpace *vs = env->gc_factory->gc_VarSpace, *next; vs != NULL; vs = next) {
+    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);
@@ -506,7 +506,7 @@ static void freeValue(af_Environment *env) {
         }
     }
 
-    for (af_Var *var = env->gc_factory->gc_Var, *next; var != NULL; var = next) {
+    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);
@@ -524,10 +524,10 @@ static void freeValue(af_Environment *env) {
  * @return
  */
 static pgc_Analyzed checkDestruct(af_Environment *env, paf_GuardianList *pgl, pgc_Analyzed plist) {
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
+    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, NULL, od, env);
-            if (func == NULL)
+            af_Object *func = findObjectAttributesByObjectData(mg_gc_destruct, nullptr, od, env);
+            if (func == nullptr)
                 continue;
             od->gc.done_destruct = true;
 
@@ -544,8 +544,8 @@ static pgc_Analyzed checkDestruct(af_Environment *env, paf_GuardianList *pgl, pg
 }
 
 af_GuardianList *gc_RunGC(af_Environment *base) {
-    gc_Analyzed *analyzed = NULL;
-    af_GuardianList *gl = NULL;
+    gc_Analyzed *analyzed = nullptr;
+    af_GuardianList *gl = nullptr;
     pgc_Analyzed plist = &analyzed;
     paf_GuardianList pgl = &gl;
     base = base->base;  // 切换到主线程
@@ -557,7 +557,7 @@ af_GuardianList *gc_RunGC(af_Environment *base) {
     plist = iterEnvironment(base, plist);
 
     pthread_mutex_lock(&base->thread_lock);
-    for (af_EnvironmentList *envl = base->env_list; envl != NULL; envl = envl->next)
+    for (af_EnvironmentList *envl = base->env_list; envl != nullptr; envl = envl->next)
         plist = iterEnvironment(envl->env, plist);
     pthread_mutex_unlock(&base->thread_lock);
 
@@ -583,10 +583,10 @@ 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 != NULL; od = od->gc.next) {
+    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, NULL, od, env);
-            if (func == NULL)
+            af_Object *func = findObjectAttributesByObjectData(mg_gc_destruct, nullptr, od, env);
+            if (func == nullptr)
                 continue;
             od->gc.done_destruct = true;
 
@@ -609,7 +609,7 @@ 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 != NULL; od = od->gc.next) {
+    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);
@@ -623,16 +623,16 @@ 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 != NULL; od = base->gc_factory->gc_ObjectData)
+    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 != NULL; obj = base->gc_factory->gc_Object)
+    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 != NULL; vs = base->gc_factory->gc_VarSpace)
+    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 != NULL; var = base->gc_factory->gc_Var)
+    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);
 }
@@ -644,7 +644,7 @@ void gc_freeAllValue(af_Environment *env) {
  */
 void printGCByCore(af_Environment *env) {
     bool success = true;
-    for (af_ObjectData *od = env->gc_factory->gc_ObjectData; od != NULL; od = od->gc.next) {
+    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;
@@ -652,7 +652,7 @@ void printGCByCore(af_Environment *env) {
             writeTrackLog(aFunCoreLogger, "GC Reference ObjectData(%p): %d", od, od->gc.info.reference);
     }
 
-    for (af_Object *obj = env->gc_factory->gc_Object; obj != NULL; obj = obj->gc.next) {
+    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;
@@ -660,7 +660,7 @@ void printGCByCore(af_Environment *env) {
             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 != NULL; vs = vs->gc.next) {
+    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;
@@ -668,7 +668,7 @@ void printGCByCore(af_Environment *env) {
             writeTrackLog(aFunCoreLogger, "GC Reference VarSpace(%p): %d", vs, vs->gc.info.reference);
     }
 
-    for (af_Var *var = env->gc_factory->gc_Var; var != NULL; var = var->gc.next) {
+    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;

src/core/global_obj.c → src/core/global_obj.cpp

@@ -1,23 +1,23 @@
-#include "aFunCore.h"
-#include "__object.h"
+#include "aFunCore.hpp"
+#include "__object.hpp"
 
 typedef struct GlobalObjectData GlobalObjectData;
 struct GlobalObjectData {
     af_VarSpace *share;
 };
 
-static char *global_id = "global-object";
+static const char *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) {
-    god->share = NULL;
+static void freeGOD(GlobalObjectData *god, af_Object  *obj, af_Environment *env) {  // NOLINT 必备参数
+    god->share = nullptr;
 }
 
-static size_t getSize(char *id, af_Object *obj) {
+static size_t getSize(char *id, af_Object *obj) {  // NOLINT 必备参数
     /* 不需要检查 id */
     return sizeof(GlobalObjectData);
 }
@@ -32,19 +32,19 @@ static void freeData(char *id, af_Object *obj, GlobalObjectData *data, af_Enviro
         freeGOD(data, obj, env);
 }
 
-static af_GcList *getGcList(char *id, af_Object *obj, GlobalObjectData *data) {
+static af_GcList *getGcList(char *id, af_Object *obj, GlobalObjectData *data) {  // NOLINT 必备参数
     if (!EQ_STR(id, global_id))
-        return NULL;
+        return nullptr;
 
-    if (data->share != NULL)
-        return pushGcList(glt_vs, data->share, NULL);
-    return NULL;
+    if (data->share != nullptr)
+        return pushGcList(glt_vs, data->share, nullptr);
+    return nullptr;
 }
 
 
 static af_VarSpace *getShareVS(char *id, af_Object *obj) {
     if (!EQ_STR(id, global_id))
-        return NULL;
+        return nullptr;
     return ((GlobalObjectData *)getObjectData(obj))->share;
 }
 
@@ -56,15 +56,15 @@ af_Object *makeGlobalObject(af_Environment *env) {
     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 NULL;
+        return nullptr;
     if (addAPI(init_data, "obj_initData", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(free_data, "obj_destructData", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(get_share_vs, "obj_getShareVarSpace", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(get_gl, "obj_getGcList", api) != 1)
-        return NULL;
+        return nullptr;
 
     FREE_SYMBOL(get_size);
     FREE_SYMBOL(init_data);
@@ -72,5 +72,5 @@ af_Object *makeGlobalObject(af_Environment *env) {
     FREE_SYMBOL(get_share_vs);
     FREE_SYMBOL(get_gl);
 
-    return makeObject(global_id, true, api, true, NULL, true, NULL, env);
+    return makeObject(global_id, true, api, true, nullptr, true, nullptr, env);
 }

src/core/lexical.c → src/core/lexical.cpp

@@ -3,8 +3,8 @@
  * 目标: aFunlang词法分析
  */
 #include <ctype.h>
-#include "aFunCore.h"
-#include "__parser.h"
+#include "aFunCore.hpp"
+#include "__parser.hpp"
 #include "parserl_warning_error.h"
 
 #ifndef isascii
@@ -338,17 +338,17 @@ af_TokenType getTokenFromLexical(char **text, af_Parser *parser) {
     parser->lexical->last = 0;
 
     if (parser->lexical->is_end) {
-        *text = NULL;
+        *text = nullptr;
         return TK_EOF;
     } else if (parser->lexical->is_error || parser->reader->read_error) {  /* lexical和reader出现异常后不再执行 */
-        *text = NULL;
+        *text = nullptr;
         return TK_ERROR;
     }
 
-    while (1) {
+    while (true) {
         char ch = getChar(parser->reader);
         if (parser->reader->read_error) {
-            *text = NULL;
+            *text = nullptr;
             return TK_ERROR;
         }
 
@@ -396,7 +396,7 @@ af_TokenType getTokenFromLexical(char **text, af_Parser *parser) {
 
         if (re == ERROR_TOKEN) {
             tt = TK_ERROR;
-            *text = NULL;
+            *text = nullptr;
             break;
         } else if (re == DEL_TOKEN) {  // 删除该token, 继续执行
             char *word = readWord(parser->lexical->last, parser->reader);
@@ -406,9 +406,9 @@ af_TokenType getTokenFromLexical(char **text, af_Parser *parser) {
             continue;
         } else if (re == FINISH_TOKEN) {
             char *word = readWord(parser->lexical->last, parser->reader);
-            if (word == NULL) {
+            if (word == nullptr) {
                 tt = TK_ERROR;
-                *text = NULL;
+                *text = nullptr;
                 break;
             }
 
@@ -417,7 +417,7 @@ af_TokenType getTokenFromLexical(char **text, af_Parser *parser) {
             if (tt == TK_ELEMENT_SHORT || tt == TK_PREFIX)
                 *text = word;
             else if (tt == TK_ELEMENT_LONG) {
-                char *new = NEW_STR(STR_LEN(word) - 2);  // 去除收尾|
+                char *new_str = NEW_STR(STR_LEN(word) - 2);  // 去除收尾|
 
                 bool flat = false;
                 char *p = word + 1;
@@ -430,13 +430,13 @@ af_TokenType getTokenFromLexical(char **text, af_Parser *parser) {
                         break;
                     else
                         flat = false;
-                    new[count] = *p;
+                    new_str[count] = *p;
                     count++;
                 }
 
-                *text = strCopy(new);
+                *text = strCopy(new_str);
                 free(word);
-                free(new);
+                free(new_str);
             } else
                 free(word);
 

src/core/monitor.c → src/core/monitor.cpp

@@ -1,16 +1,15 @@
-#include "__monitor.h"
-#include "__env.h"
+#include "__monitor.hpp"
 
 static void *monitorProgress(void *m);
 
 af_Monitor *makeMonitor(af_Environment *env) {
-    af_Monitor *monitor = calloc(1, sizeof(af_Monitor));
+    auto monitor = calloc(1, af_Monitor);
     monitor->env = env;
-    pthread_mutex_init(&monitor->lock, NULL);
-    pthread_cond_init(&monitor->cond, NULL);
+    pthread_mutex_init(&monitor->lock, nullptr);
+    pthread_cond_init(&monitor->cond, nullptr);
 
     env->monitor = monitor;
-    pthread_create(&monitor->thread, NULL, monitorProgress, monitor);
+    pthread_create(&monitor->thread, nullptr, monitorProgress, monitor);
     return monitor;
 }
 
@@ -22,21 +21,21 @@ void freeMonitor(af_Environment *env) {
     pthread_mutex_unlock(&monitor->lock);
     pthread_cond_signal(&monitor->cond);
 
-    pthread_join(monitor->thread, NULL);
+    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 = NULL;
+    env->monitor = nullptr;
     pthread_mutex_unlock(&env->thread_lock);
 }
 
 static void *monitorProgress(void *m) {
-    af_Monitor *monitor = m;
+    af_Monitor *monitor = (af_Monitor *)m;
     af_Environment *env = monitor->env;
     pthread_mutex_lock(&monitor->lock);
-    while (1) {
+    while (true) {
         if (isEnviromentExit(env)) {
             pthread_mutex_lock(&monitor->env->status_lock);
             monitor->env->status = core_exit;
@@ -48,5 +47,5 @@ static void *monitorProgress(void *m) {
             break;
     }
     pthread_mutex_unlock(&monitor->lock);
-    return NULL;
+    return nullptr;
 }

src/core/object.c → src/core/object.cpp

@@ -1,77 +1,77 @@
-#include "__object.h"
-#include "tool.h"
-#include "core_init.h"
+#include "__object.hpp"
+#include "tool.hpp"
+#include "core_init.hpp"
 
 
 /* ObjectData API 创建与释放 */
-static af_ObjectAPINode *makeObjectAPINode(DLC_SYMBOL(objectAPIFunc) func, char *api_name);
+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(char *api_name, af_ObjectData *od);
-static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af_ObjectData *od);
+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);
 
 
 /*
  * 函数名: 创建一个object
  * 目标: 生成Object和ObjectData, 并且添加到gc链表中
- * 若处于初始化模式, 则belong, inherit等可以设置为NULL, 由后期统一填上
+ * 若处于初始化模式, 则belong, inherit等可以设置为nullptr, 由后期统一填上
  */
-af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inherit, af_Object *belong,
+af_Object *makeObject(const char *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 == NULL) {
+    if (api == nullptr) {
         api = makeObjectAPI();
         free_api = true;
     }
 
-    af_Inherit *ih = NULL;
-    if (inherit != NULL)
+    af_Inherit *ih = nullptr;
+    if (inherit != nullptr)
         ih = inherit;
     else {
         free_inherit = true;
-        if (env->global != NULL)
+        if (env->global != nullptr)
             ih = makeInherit(env->global);
         else if (status != core_creat)
             writeFatalErrorLog(aFunCoreLogger, 1, "Make object inherit null");
     }
 
-    if (belong == NULL) {
-        if (env->activity != 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=NULL
+        else if (status != core_creat)  // 只有creat可以使用belong=nullptr
             writeFatalErrorLog(aFunCoreLogger, 1, "Make object belong null");
     }
 
-    af_Object *obj = calloc(1, sizeof(af_Object));
-    af_ObjectData *od = calloc(1, sizeof(af_ObjectData));
+    auto obj = calloc(1, af_Object);
+    auto od = calloc(1, af_ObjectData);
 
-    obj->belong = NULL;
+    obj->belong = nullptr;
     od->base = obj;
     obj->data = od;
-    od->id = strCopy(id == NULL ? "Unknown" : id);
+    od->id = strCopy(id == nullptr ? "Unknown" : id);
 
     od->api = api;
     od->free_api = free_api;
 
     od->allow_inherit = allow_inherit;
-    od->inherit = NULL;
+    od->inherit = nullptr;
 
-    obj_getDataSize *func = findAPI("obj_getDataSize", api);
-    if (func != NULL)
+    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(1, od->size);
+        od->data = calloc_size(1, od->size);
 
-    pthread_rwlock_init(&od->lock, NULL);
-    pthread_rwlock_init(&obj->lock, NULL);
+    pthread_rwlock_init(&od->lock, nullptr);
+    pthread_rwlock_init(&obj->lock, nullptr);
 
     obj->belong = belong;
     obj->data->inherit = ih;
@@ -82,8 +82,8 @@ af_Object *makeObject(char *id, bool free_api, af_ObjectAPI *api, bool allow_inh
     gc_addObject(obj, env->base);
 
     if (obj->data->size != 0) {  // 要在 add_object 之后再运行 init
-        obj_initData *init = findAPI("obj_initData", obj->data->api);
-        if (init != NULL)
+        auto init = (obj_initData *)findAPI("obj_initData", obj->data->api);
+        if (init != nullptr)
             init(id, obj, obj->data->data, env);
     }
 
@@ -103,8 +103,8 @@ void freeObjectDataData(af_ObjectData *od, af_Environment *env) {
         pthread_rwlock_unlock(&od->lock);
         return;
     }
-    obj_destructData *func = findAPI("obj_destructData", od->api);
-    if (func != NULL)
+    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);
@@ -118,8 +118,8 @@ void freeObjectDataData(af_ObjectData *od, af_Environment *env) {
  */
 void freeObjectData(af_ObjectData *od, af_Environment *env) {
     if (od->size != 0) {
-        obj_destructData *func = findAPI("obj_destructData", od->api);
-        if (func != NULL)
+        auto func = (obj_destructData * )findAPI("obj_destructData", od->api);
+        if (func != nullptr)
             func(od->id, od->base, od->data, env);
     }
 
@@ -154,27 +154,27 @@ void *getObjectData(af_Object *obj) {
 
 af_Object *getBelongObject(af_Object *object){
     pthread_rwlock_wrlock(&object->lock);
-    af_Object *belong = (object->belong == NULL ? object : object->belong);
+    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 NULL;
+        return nullptr;
 
-    obj_getShareVarSpace *func = findAPI("obj_getShareVarSpace", getObjectAPI(obj));
-    af_VarSpace *vs = NULL;
-    if (func == NULL)
-        return NULL;
+    auto func = (obj_getShareVarSpace *)findAPI("obj_getShareVarSpace", getObjectAPI(obj));
+    af_VarSpace *vs;
+    if (func == nullptr)
+        return nullptr;
 
-    if ((vs = func(getObjectID(obj), obj)) == NULL)
-        return NULL;
+    if ((vs = func(getObjectID(obj), obj)) == nullptr)
+        return nullptr;
 
-    af_Inherit *ih = calloc(1, sizeof(af_Inherit));
+    auto ih = calloc(1, af_Inherit);
     ih->vs = vs;
     ih->obj = obj;  // 调用API获取vs
-    pthread_rwlock_init(&ih->lock, NULL);
+    pthread_rwlock_init(&ih->lock, nullptr);
     return ih;
 }
 
@@ -185,11 +185,11 @@ af_Inherit *makeInherit(af_Object *obj) {
  * @param new
  * @return
  */
-af_Inherit **pushInherit(af_Inherit **base, af_Inherit *new) {
-    while ((*base) != NULL)
+af_Inherit **pushInherit(af_Inherit **base, af_Inherit *new_ih) {
+    while ((*base) != nullptr)
         base = &((*base)->next);
-    *base = new;
-    while ((*base) != NULL)
+    *base = new_ih;
+    while ((*base) != nullptr)
         base = &((*base)->next);
     return base;
 }
@@ -202,7 +202,7 @@ static af_Inherit *freeInherit(af_Inherit *ih) {
 }
 
 void freeAllInherit(af_Inherit *ih) {
-    while (ih != NULL)
+    while (ih != nullptr)
         ih = freeInherit(ih);
 }
 
@@ -211,7 +211,7 @@ bool checkPosterity(af_Object *base, af_Object *posterity) {
     af_ObjectData *data = posterity->data;
     pthread_rwlock_unlock(&posterity->lock);
 
-    for (af_Inherit *ih = getObjectInherit(base); ih != NULL; ih = getInheritNext(ih)) {
+    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) {
@@ -224,11 +224,11 @@ bool checkPosterity(af_Object *base, af_Object *posterity) {
     return false;
 }
 
-static af_ObjectAPINode *makeObjectAPINode(DLC_SYMBOL(objectAPIFunc) func, char *api_name) {
-    if (func == NULL)
-        return NULL;
+static af_ObjectAPINode *makeObjectAPINode(DLC_SYMBOL(objectAPIFunc) func, const char *api_name) {
+    if (func == nullptr)
+        return nullptr;
 
-    af_ObjectAPINode *apin = calloc(1, sizeof(af_ObjectAPINode));
+    auto apin = calloc(1, af_ObjectAPINode);
     apin->api = COPY_SYMBOL(func, objectAPIFunc);
     apin->name = strCopy(api_name);
     return apin;
@@ -243,13 +243,13 @@ static af_ObjectAPINode *freeObjectAPINode(af_ObjectAPINode *apin) {
 }
 
 static void freeAllObjectAPINode(af_ObjectAPINode *apin) {
-    while (apin != NULL)
+    while (apin != nullptr)
         apin = freeObjectAPINode(apin);
 }
 
-af_ObjectAPI *makeObjectAPI(void) {
-    af_ObjectAPI *api = calloc(1, sizeof(af_ObjectAPI));
-    pthread_rwlock_init(&api->lock, NULL);
+af_ObjectAPI *makeObjectAPI() {
+    auto api = calloc(1, af_ObjectAPI);
+    pthread_rwlock_init(&api->lock, nullptr);
     return api;
 }
 
@@ -267,13 +267,13 @@ void freeObjectAPI(af_ObjectAPI *api) {
  * 若dlc中不存在指定函数则返回-1且不作修改
  * 操作成功返回1
  */
-int addAPI(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af_ObjectAPI *api) {
+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 != NULL; pNode = &((*pNode)->next)) {
+    for(NULL; *pNode != nullptr; pNode = &((*pNode)->next)) {
         if (EQ_STR((*pNode)->name, api_name)) {
             pthread_rwlock_unlock(&api->lock);
             return 0;
@@ -283,7 +283,7 @@ int addAPI(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af_ObjectAPI *api) {
     *pNode = makeObjectAPINode(func, api_name);
 
     int res = -1;
-    if (*pNode != NULL) {
+    if (*pNode != nullptr) {
         api->count++;
         res = 1;
     }
@@ -292,12 +292,12 @@ int addAPI(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af_ObjectAPI *api) {
     return res;
 }
 
-void *findAPI(char *api_name, af_ObjectAPI *api) {
+objectAPIFunc *findAPI(const char *api_name, af_ObjectAPI *api) {
     time33_t index = time33(api_name) % API_HASHTABLE_SIZE;
-    void *data = NULL;
+    objectAPIFunc *data = nullptr;
     pthread_rwlock_rdlock(&api->lock);
 
-    for (af_ObjectAPINode *node = api->node[index]; node != NULL; node = node->next) {
+    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;
@@ -315,7 +315,7 @@ void *findAPI(char *api_name, af_ObjectAPI *api) {
  * 若dlc中不存在指定函数则返回-1且不作修改
  * 操作成功返回1
  */
-static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, char *api_name,
+static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, const char *api_name,
                               af_ObjectData *od) {
     time33_t index = time33(api_name) % API_HASHTABLE_SIZE;
 
@@ -325,7 +325,7 @@ static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, char *api_name,
 
     pthread_rwlock_wrlock(&api->lock);
     af_ObjectAPINode **pNode = &api->node[index];
-    for (NULL; *pNode != NULL; pNode = &((*pNode)->next)) {
+    for(NULL; *pNode != nullptr; pNode = &((*pNode)->next)) {
         if (EQ_STR((*pNode)->name, api_name)) {
             pthread_rwlock_unlock(&api->lock);
             return 0;
@@ -335,7 +335,7 @@ static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, char *api_name,
     *pNode = makeObjectAPINode(func, api_name);
 
     int res = -1;
-    if (*pNode != NULL) {
+    if (*pNode != nullptr) {
         api->count++;
         res = 1;
     }
@@ -344,17 +344,17 @@ static int addAPIToObjectData(DLC_SYMBOL(objectAPIFunc) func, char *api_name,
     return res;
 }
 
-static af_ObjectAPINode *findObjectDataAPINode(char *api_name, af_ObjectData *od) {
+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);
 
-    void *data = NULL;
+    af_ObjectAPINode *data = nullptr;
     pthread_rwlock_rdlock(&api->lock);
 
-    for (af_ObjectAPINode *node = api->node[index]; node != NULL; node = node->next) {
+    for (af_ObjectAPINode *node = api->node[index]; node != nullptr; node = node->next) {
         if (EQ_STR(node->name, api_name)) {
             data = node;
             break;
@@ -369,7 +369,7 @@ static af_ObjectAPINode *findObjectDataAPINode(char *api_name, af_ObjectData *od
  * 函数名: findObjectDataAPINode
  * 目标: 从DLC中获取函数并写入Object的API
  */
-int addAPIToObject(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af_Object *obj) {
+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);
@@ -381,37 +381,37 @@ int addAPIToObject(DLC_SYMBOL(objectAPIFunc) func, char *api_name, af_Object *ob
  * 函数名: findObjectAPI
  * 目标: 从Object中获取指定api的函数指针
  */
-void *findObjectAPI(char *api_name, af_Object *obj) {
+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 == NULL)
-        return NULL;
+    if (node == nullptr)
+        return nullptr;
     return GET_SYMBOL(node->api);
 }
 
-af_Object *findObjectAttributes(char *name, af_Object *visitor, af_Object *obj, af_Environment *env){
+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 != NULL)
-        return findVarNode(var, NULL, env);
+    if (var != nullptr)
+        return findVarNode(var, nullptr, env);
 
-    for (af_Inherit *ih = getObjectInherit(obj); ih != NULL; ih = getInheritNext(ih)) {
+    for (af_Inherit *ih = getObjectInherit(obj); ih != nullptr; ih = getInheritNext(ih)) {
         var = findVarFromVarSpace(name, visitor, getInheritVarSpace(ih));  // 搜索共享变量空间
-        if (var != NULL)
-            return findVarNode(var, NULL, env);
+        if (var != nullptr)
+            return findVarNode(var, nullptr, env);
     }
 
-    return NULL;
+    return nullptr;
 }
 
 /**
  * 添加属性到Object中
  * 注意: 必须保证 obj 又被 gc 引用
  */
-bool setObjectAttributes(char *name, char p_self, char p_posterity, char p_external, af_Object *attributes,
+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);
 }
@@ -423,25 +423,25 @@ bool setObjectAttributes(char *name, char p_self, char p_posterity, char p_exter
  * @param od
  * @return
  */
-af_Object *findObjectAttributesByObjectData(char *name, af_Object *visitor, af_ObjectData *od, af_Environment *env){
+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 != NULL)
-        return findVarNode(var, NULL, env);
+    if (var != nullptr)
+        return findVarNode(var, nullptr, env);
 
-    for (NULL; ih != NULL; ih = getInheritNext(ih)) {
+    for(NULL; ih != nullptr; ih = getInheritNext(ih)) {
         var = findVarFromVarSpace(name, visitor, getInheritVarSpace(ih));  // 搜索共享变量空间
-        if (var != NULL)
-            return findVarNode(var, NULL, env);
+        if (var != nullptr)
+            return findVarNode(var, nullptr, env);
     }
 
-    return NULL;
+    return nullptr;
 }
 
-char *getObjectID(af_Object *obj) {
+const char *getObjectID(af_Object *obj) {
     pthread_rwlock_rdlock(&obj->lock);
     af_ObjectData *data = obj->data;
     pthread_rwlock_unlock(&obj->lock);

src/core/parser.c → src/core/parser.cpp

@@ -3,19 +3,19 @@
  * 目标: __parser.h中结构体的相关函数
  */
 
-#include "aFunCore.h"
-#include "tool.h"
-#include "__parser.h"
+#include "aFunCore.hpp"
+#include "tool.hpp"
+#include "__parser.hpp"
 
-static af_Lexical *makeLexical(void);
+static af_Lexical *makeLexical();
 static void freeLexical(af_Lexical *lex);
-static af_Syntactic *makeSyntactic(void);
+static af_Syntactic *makeSyntactic();
 static void freeSyntactic(af_Syntactic *syntactic);
-static bool getStdinSignalFunc(void);
+static bool getStdinSignalFunc();
 
-af_Parser *makeParser(FilePath file, DLC_SYMBOL(readerFunc) read_func, DLC_SYMBOL(destructReaderFunc) destruct_func,
+af_Parser *makeParser(ConstFilePath file, DLC_SYMBOL(readerFunc) read_func, DLC_SYMBOL(destructReaderFunc) destruct_func,
                       size_t data_size){
-    af_Parser *parser = calloc(1, sizeof(af_Parser));
+    auto parser = calloc(1, af_Parser);
     parser->reader = makeReader(1, file, read_func, destruct_func, data_size);
     parser->lexical = makeLexical();
     parser->syntactic = makeSyntactic();
@@ -33,8 +33,8 @@ void initParser(af_Parser *parser) {
     initReader(parser->reader);
 }
 
-static af_Lexical *makeLexical(void) {
-    af_Lexical *lex = calloc(1, sizeof(af_Lexical));
+static af_Lexical *makeLexical() {
+    auto lex = calloc(1, af_Lexical);
     lex->status = lex_begin;
     return lex;
 }
@@ -43,8 +43,8 @@ static void freeLexical(af_Lexical *lex) {
     free(lex);
 }
 
-static af_Syntactic *makeSyntactic(void) {
-    af_Syntactic *syntactic = calloc(1, sizeof(af_Syntactic));
+static af_Syntactic *makeSyntactic() {
+    auto syntactic = calloc(1, af_Syntactic);
     return syntactic;
 }
 
@@ -63,7 +63,7 @@ static void freeSyntactic(af_Syntactic *syntactic) {
 
 struct readerDataString {
     af_Parser *parser;
-    char *str;
+    const char *str;
     bool free_str;
     size_t index;
     size_t len;
@@ -83,22 +83,24 @@ static size_t readFuncString(struct readerDataString *data, char *dest, size_t l
 }
 
 static void destructFunc(struct readerDataString *data) {
-    if (data->free_str)
-        free(data->str);
+    if (data->free_str) {
+        char *tmp = const_cast<char *>(data->str);
+        free(tmp);
+    }
 }
 
-static void initStringReader(af_Parser *parser, char *str, bool free_str, struct readerDataString *data) {
+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(FilePath name, char *str, bool free_str){
+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, parser->reader->data);
+    initStringReader(parser, str, free_str, (struct readerDataString *)parser->reader->data);
     initParser(parser);
     FREE_SYMBOL(read_func);
     FREE_SYMBOL(destruct);
@@ -145,7 +147,7 @@ static size_t readFuncFile(struct readerDataFile *data, char *dest, size_t len,
 }
 
 static void destructFile(struct readerDataFile *data) {
-    if (data->file != NULL)
+    if (data->file != nullptr)
         fileClose(data->file);
 }
 
@@ -154,18 +156,18 @@ static void initFileReader(af_Parser *parser, FILE *file, struct readerDataFile
     data->parser = parser;
 }
 
-af_Parser *makeParserByFile(FilePath path){
+af_Parser *makeParserByFile(ConstFilePath path){
     FILE *file = fileOpen(path, "rb");
-    if (file == NULL) {
+    if (file == nullptr) {
         writeErrorLog(aFunCoreLogger, "File open error: %s", path);
-        return NULL;
+        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, parser->reader->data);
+    initFileReader(parser, file, (struct readerDataFile *)parser->reader->data);
     initParser(parser);
     FREE_SYMBOL(read_func);
     FREE_SYMBOL(destruct);
@@ -176,15 +178,15 @@ struct readerDataStdin {
     af_Parser *parser;
     bool no_first;
 
-    void *sig_int;
-    void *sig_term;
+    __p_sig_fn_t sig_int;
+    __p_sig_fn_t sig_term;
 
     char *data;
     size_t index;
     size_t len;
 };
 
-static bool getStdinSignalFunc(void) {
+static bool getStdinSignalFunc() {
     return aFunGetSignal(SIGINT) || aFunGetSignal(SIGTERM);
 }
 
@@ -257,14 +259,14 @@ static void initStdinReader(af_Parser *parser, struct readerDataStdin *data) {
     data->parser = parser;
 }
 
-af_Parser *makeParserByStdin(FilePath file){
+af_Parser *makeParserByStdin(ConstFilePath file){
     if (CLEAR_FERROR(stdin))
-        return NULL;
+        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, parser->reader->data);
+    initStdinReader(parser, (struct readerDataStdin *)parser->reader->data);
     initParser(parser);
     FREE_SYMBOL(read_func);
     FREE_SYMBOL(destruct);

src/core/reader.c → src/core/reader.cpp

@@ -1,14 +1,14 @@
-#include "core_init.h"
-#include "__reader.h"
+#include "core_init.hpp"
+#include "__reader.hpp"
 static void readFirstWord(af_Reader *reader);
 
-af_Reader *makeReader(FileLine line, FilePath file, DLC_SYMBOL(readerFunc) read_func,
+af_Reader *makeReader(FileLine line, ConstFilePath file, DLC_SYMBOL(readerFunc) read_func,
                       DLC_SYMBOL(destructReaderFunc) destruct_func, size_t data_size){
-    af_Reader *reader = calloc(1, sizeof(af_Reader));
+    auto reader = calloc(1, af_Reader);
     reader->read_func = COPY_SYMBOL(read_func, readerFunc);
     reader->destruct = COPY_SYMBOL(destruct_func, destructReaderFunc);
 
-    reader->data = calloc(1, data_size);
+    reader->data = calloc_size(1, data_size);
     reader->data_size = data_size;
 
     reader->buf = NEW_STR(DEFAULT_BUF_SIZE);
@@ -29,7 +29,7 @@ af_Reader *initReader(af_Reader *reader) {
 }
 
 void freeReader(af_Reader *reader) {
-    if (reader->destruct != NULL)
+    if (reader->destruct != nullptr)
         GET_SYMBOL(reader->destruct)(reader->data);
     free(reader->data);
     free(reader->buf);
@@ -49,7 +49,7 @@ char *readWord(size_t del_index, af_Reader *reader) {
     reader->read = reader->buf;  // 重置指针
 
     if (del_index == 0)
-        return strCopy(NULL);  // 返回空字符串
+        return strCopy(nullptr);  // 返回空字符串
 
     re = NEW_STR(del_index);
     memcpy(re, reader->buf, del_index);  // 复制旧字符串
@@ -80,7 +80,7 @@ char *readWord(size_t del_index, af_Reader *reader) {
     if (!isCharUTF8(re)) {
         free(re);
         writeErrorLog(aFunCoreLogger, "Is not utf-8");
-        return NULL;
+        return nullptr;
     }
 
     return re;

src/core/run.c → src/core/run.cpp

@@ -1,6 +1,6 @@
-#include "aFunCore.h"
-#include "__run.h"
-#include "__env.h"
+#include "aFunCore.hpp"
+#include "__run.hpp"
+#include "__env.hpp"
 
 /* 工具函数: 初始化类型 */
 static bool iterCodeInit(af_Code *code, int mode, af_Environment *env);
@@ -27,9 +27,9 @@ static bool runGuardian(af_Environment *env);
  * 目标: 检查type是否在对应的msg_type中 (检查该activity是否可以处理该信息)
  */
 static bool checkInMsgType(char *type, af_Environment *env) {
-    if (env->activity->body_next == NULL || env->activity->body_next->msg_type == NULL)
+    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 != NULL; msg_type_node++) {
+    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;
     }
@@ -43,23 +43,23 @@ static bool checkInMsgType(char *type, af_Environment *env) {
 static bool checkLiteral(af_Message **msg, af_Environment *env) {
     if (!env->activity->is_literal)  // 非字面量
         return true;
-    if ((*msg) == NULL || !EQ_STR((*msg)->type, "NORMAL"))  // (*msg)非正常值
+    if ((*msg) == nullptr || !EQ_STR((*msg)->type, "NORMAL"))  // (*msg)非正常值
         return false;
 
     af_Object *obj = *(af_Object **)((*msg)->msg);
-    obj_literalSetting *func = findAPI("obj_literalSetting", getObjectAPI(obj));
-    if (func == NULL) {
+    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 != NULL; ld = ld->next)
+    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 = NULL;
+    env->activity->ld = nullptr;
     env->activity->is_literal = false;
     writeTrackLog(aFunCoreLogger, "Literal %p", obj);
     return true;
@@ -74,7 +74,7 @@ static bool checkLiteral(af_Message **msg, af_Environment *env) {
  *  1 宏函数
  */
 static int checkMacro(af_Message *msg, af_Environment *env) {
-    if (env->activity->fi == NULL || !env->activity->fi->is_macro)  // 非宏函数
+    if (env->activity->fi == nullptr || !env->activity->fi->is_macro)  // 非宏函数
         return -1;
     if (!EQ_STR(msg->type, "NORMAL"))  // msg非正常值
         return -1;
@@ -99,9 +99,9 @@ static int checkMacro(af_Message *msg, af_Environment *env) {
  * 3. gc模式
  */
 static bool iterCodeInit(af_Code *code, int mode, af_Environment *env) {
-    if (env == NULL || pthread_mutex_trylock(&env->in_run) != 0)
+    if (env == nullptr || pthread_mutex_trylock(&env->in_run) != 0)
         return false;
-    if (env->activity == NULL) {
+    if (env->activity == nullptr) {
         pthread_mutex_unlock(&env->in_run);
         return false;
     }
@@ -110,7 +110,7 @@ static bool iterCodeInit(af_Code *code, int mode, af_Environment *env) {
         case 0:
             if (env->activity->type != act_top || !codeSemanticCheck(code))
                 return false;
-            setActivityBtTop(NULL, env->activity);  // 直接就在NORMAL期, bt_top不被设定
+            setActivityBtTop(nullptr, env->activity);  // 直接就在NORMAL期, bt_top不被设定
             setActivityBtStart(code, env->activity);
             break;
         case 1: {
@@ -119,16 +119,16 @@ static bool iterCodeInit(af_Code *code, int mode, af_Environment *env) {
             env->activity->file = strCopy("top.aun.sys");
 
             char *name = getFileName(code->path);
-            pushImportActivity(code, NULL, name, env);
+            pushImportActivity(code, nullptr, name, env);
             free(name);
             break;
         }
         case 2:
-            if (env->activity->prev == NULL || env->activity->prev->type != act_top)
+            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 == NULL || code != NULL)
+            if (env->activity->type == act_guardian || !codeSemanticCheck(env->activity->bt_start) || env->activity->bt_next == nullptr || code != nullptr)
                 return false;
             break;
         case 3:
@@ -136,7 +136,7 @@ static bool iterCodeInit(af_Code *code, int mode, af_Environment *env) {
             env->status = core_normal_gc;
             pthread_mutex_unlock(&env->status_lock);
 
-            if (env->activity->type != act_guardian || code != NULL)
+            if (env->activity->type != act_guardian || code != nullptr)
                 return false;
             break;
         default:
@@ -168,12 +168,12 @@ static bool codeElement(af_Code *code, af_Environment *env) {
         else
             var = findVarFromVarList(func, env->activity->belong, env->activity->run_varlist);
 
-        if (var == NULL) {
+        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, NULL, env);
+        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);
@@ -183,24 +183,24 @@ static bool codeElement(af_Code *code, af_Environment *env) {
     /* 变量执行 */
     var = findVarFromVarList(code->element.data, env->activity->belong, env->activity->run_varlist);
 
-    if (var == NULL) {
+    if (var == nullptr) {
         pushMessageDown(makeERRORMessageFormat(VARIABLE_ERROR, env, "Variable not found: %s.", code->element.data), env);
         return false;
     }
 
-    af_Object *obj = findVarNode(var, NULL, env);
+    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);
-        char *id = getObjectID(obj);
-        if ((is_obj = findAPI("obj_isObjFunc", api)) != NULL && is_obj(id, obj)) {
+        const char *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 = findAPI("obj_isInfixFunc", api)) != NULL && is_infix(id, obj)) {
+                 (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);
@@ -230,17 +230,17 @@ static bool codeBlock(af_Code *code, af_Environment *env) {
 }
 
 static bool runGuardian(af_Environment *env) {
-    af_GuardianList *gl = NULL;
+    af_GuardianList *gl = nullptr;
     af_GuardianList **pgl = ≷
-    for (af_Guardian *gd = env->guardian; gd != NULL; gd = gd->next) {
+    for (af_Guardian *gd = env->guardian; gd != nullptr; gd = gd->next) {
         if (gd->always || !env->activity->is_guard) { // guardian被标记为一直执行, 或者非is_guard模式
-            af_GuardianList *new = GET_SYMBOL(gd->func)(gd->type, env->activity->is_guard, gd->data, env);
-            if (new != NULL)
-                pgl = contectGuardianList(new, pgl);
+            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 != NULL) {
+    if (gl != nullptr) {
         env->activity->process_msg_first++;  //  guardian开始处理时, 已经在原activity中有msg了, 所以要先处理
         pushGuardianActivity(gl, pgl, env);
         return true;
@@ -254,7 +254,7 @@ static bool runGuardian(af_Environment *env) {
  * 目标: 获取msg_down顶层信息, 若没有则产生错误
  */
 static af_Message *getTopMsg(af_Environment *env) {
-    if (env->activity->msg_down == NULL)  // 若未获得 msg
+    if (env->activity->msg_down == nullptr)  // 若未获得 msg
         return makeERRORMessage(RUN_ERROR, NOT_MSG_INFO, env);
     else
         return getFirstMessage(env);
@@ -275,7 +275,7 @@ static int checkMsg(af_Message *msg, af_Environment *env) {
     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 = NULL;
+        env->activity->return_obj = nullptr;
         pthread_mutex_unlock(env->activity->gc_lock);
         return 0;
     }
@@ -288,12 +288,12 @@ static int checkMsg(af_Message *msg, af_Environment *env) {
  * 目标: 检查act_normal是否运行到结尾 (若运行到结尾则返回true, 否则返回false)
  */
 bool checkNormalEnd(af_Message *msg, af_Environment *env) {
-    if (env->activity->bt_next == NULL) {
+    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 == NULL) {  // msg 得不到处理
+            if (msg == nullptr) {  // msg 得不到处理
                 pushMessageDown(makeERRORMessage(RUN_ERROR, NOT_NORMAL_MSG_INFO, env), env);
                 return true;
             }
@@ -311,11 +311,11 @@ bool checkNormalEnd(af_Message *msg, af_Environment *env) {
             checkLiteral(&msg, env);  // 检查是否字面量
             pushMessageDown(msg, env);
             return true;
-        } else if (msg != NULL) {
+        } else if (msg != nullptr) {
             gc_delObjectReference(*(af_Object **) (msg->msg), env);  // msg->msg是一个指针, 这个指针的内容是一个af_Object *
             freeMessage(msg);
         }
-    } else if (msg != NULL) {
+    } 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);
@@ -335,8 +335,8 @@ bool checkNormalEnd(af_Message *msg, af_Environment *env) {
 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 == NULL) { // 参数设定结束
-        setArgCodeListToActivity(NULL, env);
+    if (env->activity->acl_done->next == nullptr) { // 参数设定结束
+        setArgCodeListToActivity(nullptr, env);
         return true;
     }
     env->activity->acl_done = env->activity->acl_done->next;
@@ -347,9 +347,9 @@ static bool checkGetArgEnd(af_Message *msg, af_Environment *env) {
 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 != NULL)
-            popActivity(false, NULL, env);  // is_normal=false, 非正常退出, 释放mark
-        popActivity(false, NULL, env);  // 再释放 act_top
+        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;
@@ -371,7 +371,7 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
     makeMonitor(env);  // 启动监视线程
     /*
      * 问题: 如何确保循环跳出之前, top-Activity已经被pop。(即执行释放)
-     * 为什么会有这个问题: top-Activity只有在bt_next=NULL时被pop, 而循环也是在bt_next=NULL时可能被退出
+     * 为什么会有这个问题: top-Activity只有在bt_next=nullptr时被pop, 而循环也是在bt_next=nullptr时可能被退出
      *                  如此以来就可能导致在pop之前循环就退出了
      * 实际上并不会发生。
      * bt_next设定后，会出现两种情况: 一是马上检查bt_next, 而是设定了pass
@@ -388,7 +388,7 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
      */
 
     /* 必须位于act_top, 且无next, 并且无msg处理才退出执行 */
-    while (env->activity->type != act_top || env->activity->bt_next != NULL || env->activity->process_msg_first != 0) {
+    while (env->activity->type != act_top || env->activity->bt_next != nullptr || env->activity->process_msg_first != 0) {
         /* 检查是否需要退出执行 */
         if (checkStop(env)) {
             re = false;
@@ -396,8 +396,8 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
         }
 
         if (env->activity->type == act_guardian) {
-            if (env->activity->gl_next == NULL) {
-                popActivity(true, NULL, env);  // 结束运行
+            if (env->activity->gl_next == nullptr) {
+                popActivity(true, nullptr, env);  // 结束运行
                 if (mode == 3)  // mode = 3, 表示只运行守护器
                     break;
             } else
@@ -408,7 +408,7 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
         /* 切换执行的 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 != NULL)
+            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;
@@ -420,7 +420,7 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
         pthread_mutex_unlock(env->activity->gc_lock);
 
         /* 无代码运行 */
-        if (env->activity->bt_next == NULL && env->activity->process_msg_first == 0) {  // 无代码运行, 并且非msg_first
+        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:
@@ -428,7 +428,7 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
                     break;
                 case act_func_arg:  // 无参数设定
                     if (!setFuncActivityAddVar(env))
-                        popActivity(false, NULL, env);
+                        popActivity(false, nullptr, env);
                     break;
                 default:
                     break;
@@ -466,10 +466,10 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
         af_Message *msg = getTopMsg(env);
         switch (checkMsg(msg, env)) {
             case 0:  // 不可处理的信号
-                popActivity(false, NULL, env);  // 跳出当前activity
+                popActivity(false, nullptr, env);  // 跳出当前activity
                 continue;  // 下面的代码不再执行
             case 1:  // 正常信号
-                if (env->activity->return_first && env->activity->return_obj == NULL) { // 设置return_first
+                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);
@@ -482,14 +482,14 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
         }
 
         switch (env->activity->status) {
-            case act_func_normal:  // 需要考虑 msg == NULL
+            case act_func_normal:  // 需要考虑 msg == nullptr
                 if (checkNormalEnd(msg, env))
-                    popActivity(true, NULL, 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, NULL, env);
+                    popActivity(false, nullptr, env);
                 gc_delObjectReference(func, env);  // 释放计数 (setFuncActivityToArg 不需要计数)
                 freeMessage(msg);
                 break;
@@ -497,7 +497,7 @@ bool iterCode(af_Code *code, int mode, af_Environment *env){
             case act_func_arg: {
                 if (checkGetArgEnd(msg, env)) {  // 参数设定完成
                     if (!setFuncActivityAddVar(env))
-                        popActivity(false, NULL, env);
+                        popActivity(false, nullptr, env);
                 }
                 break;
             }
@@ -520,14 +520,14 @@ RETURN:
  */
 bool iterDestruct(int deep, af_Environment *env) {
     for (int count = 0; deep == 0 || deep > count; count++) {
-        af_GuardianList *gl = NULL;
+        af_GuardianList *gl = nullptr;
         paf_GuardianList pdl = ≷
 
         pdl = checkAllDestruct(env, pdl);
-        if (gl == NULL)
+        if (gl == nullptr)
             return true;
         pushGuardianActivity(gl, pdl, env);
-        if (!iterCode(NULL, 3, env))
+        if (!iterCode(nullptr, 3, env))
             return false;
     }
 

src/core/sig.c → src/core/sig.cpp

@@ -1,10 +1,10 @@
-#include "aFunCore.h"
-#include "__sig.h"
+#include "aFunCore.hpp"
+#include "__sig.hpp"
 #include "pthread.h"
 
 struct af_SignalInfo {
-    void *sig_int;
-    void *sig_term;
+    __p_sig_fn_t sig_int;
+    __p_sig_fn_t sig_term;
 
     volatile sig_atomic_t flat_int;  // SIGUSR1 (*nix)
     volatile sig_atomic_t flat_term;  // SIGUSR1 (*nix)
@@ -13,14 +13,14 @@ struct af_SignalInfo {
     volatile sig_atomic_t flat_u1;  // SIGUSR1 (*nix)
     volatile sig_atomic_t flat_u2;  // SIGUSR1 (*nix)
 
-    void *sig_u1;
-    void *sig_u2;
+    __p_sig_fn_t sig_u1;
+    __p_sig_fn_t sig_u2;
     sigset_t new;
     sigset_t old;
 #endif
 };
 
-static void aFuncheckSignal(void);
+static void aFuncheckSignal();
 typedef struct af_SignalInfo af_SignalInfo;
 af_SignalInfo sig_info;
 bool init_sig_info = false;
@@ -49,7 +49,7 @@ static void aFunSigFunc(int signum) {
 }
 #endif
 
-void aFunSignalInit(void) {
+void aFunSignalInit() {
     pthread_mutex_lock(&sig_mutex);
     if (init_sig_info) {
         pthread_mutex_unlock(&sig_mutex);
@@ -85,7 +85,7 @@ void aFunSignalInit(void) {
     pthread_mutex_unlock(&sig_mutex);
 }
 
-void aFunSignalRecover(void) {
+void aFunSignalRecover() {
     pthread_mutex_lock(&sig_mutex);
     if (!init_sig_info) {
         pthread_mutex_unlock(&sig_mutex);
@@ -93,7 +93,7 @@ void aFunSignalRecover(void) {
         return;
     }
 
-    void *re = NULL;
+    __p_sig_fn_t re;
     writeDebugLog(aFunCoreLogger, "Signal recover");
 
     if (sig_info.sig_int != SIG_ERR) {
@@ -118,12 +118,12 @@ void aFunSignalRecover(void) {
         re = signal(SIGUSR2, sig_info.sig_u2);
         assertWarningLog(re != SIG_ERR, aFunCoreLogger, "SIGUSR2 recover fail");
     }
-    sigprocmask(SIG_SETMASK, &sig_info.old, NULL);
+    sigprocmask(SIG_SETMASK, &sig_info.old, nullptr);
 #endif
     pthread_mutex_unlock(&sig_mutex);
 }
 
-static void aFuncheckSignal(void) {
+static void aFuncheckSignal() {
     /* 该函数是内部函数, 不负责加锁 */
 #ifdef aFunWIN32_NO_CYGWIN
     if (stdio_check_signal())
@@ -136,7 +136,7 @@ static void aFuncheckSignal(void) {
         signal(SIGTERM, aFunSigFunc);
         signal(SIGUSR1, aFunSigFunc);
         signal(SIGUSR2, aFunSigFunc);
-        sigprocmask(SIG_SETMASK, &sig_info.old, NULL);  // 让信号递达
+        sigprocmask(SIG_SETMASK, &sig_info.old, nullptr);  // 让信号递达
     }
     sigprocmask(SIG_BLOCK, &sig_info.new, &sig_info.old);
 #endif

src/core/syntactic.c → src/core/syntactic.cpp

@@ -1,7 +1,7 @@
-#include <ctype.h>
-#include "aFunCore.h"
-#include "__code.h"
-#include "__parser.h"
+#include <cctype>
+#include "aFunCore.hpp"
+#include "__code.hpp"
+#include "__parser.hpp"
 #include "parserl_warning_error.h"
 
 #define printSyntacticError(info, parser) do { \
@@ -30,20 +30,20 @@ static bool goBackToken(af_Parser *parser) {
 
 static af_Code *codeList(size_t deep, af_Parser *parser);
 
-static af_Code *code(size_t deep, char prefix, af_Parser *parser) {
+static af_Code *code(size_t deep, char prefix, af_Parser *parser) {  // NOLINT
     af_Code *re;
-    af_Code *code_list = NULL;
+    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, NULL);
-            if (re == NULL) {
+            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 NULL;
+                return nullptr;
             }
             free(parser->syntactic->text);
             break;
@@ -59,14 +59,14 @@ static af_Code *code(size_t deep, char prefix, af_Parser *parser) {
                     break;
                 case TK_ERROR:
                     freeAllCode(code_list);
-                    return NULL;
+                    return nullptr;
                 default:
                     goBackToken(parser);
                     printSyntacticError(CodeBlockEndError, parser);
                     break;
             }
 
-            re = makeBlockCode(parentheses, code_list, prefix, parser->reader->line, NULL, NULL);
+            re = makeBlockCode(parentheses, code_list, prefix, parser->reader->line, nullptr, nullptr);
             break;
         case TK_LB:
             if (deep <= SYNTACTIC_MAX_DEEP)
@@ -80,14 +80,14 @@ static af_Code *code(size_t deep, char prefix, af_Parser *parser) {
                     break;
                 case TK_ERROR:
                     freeAllCode(code_list);
-                    return NULL;
+                    return nullptr;
                 default:
                     goBackToken(parser);
                     printSyntacticError(CodeBlockEndError, parser);
                     break;
             }
 
-            re = makeBlockCode(brackets, code_list, prefix, parser->reader->line, NULL, NULL);
+            re = makeBlockCode(brackets, code_list, prefix, parser->reader->line, nullptr, nullptr);
             break;
         case TK_LC:
             if (deep <= SYNTACTIC_MAX_DEEP)
@@ -101,28 +101,28 @@ static af_Code *code(size_t deep, char prefix, af_Parser *parser) {
                     break;
                 case TK_ERROR:
                     freeAllCode(code_list);
-                    return NULL;
+                    return nullptr;
                 default:
                     goBackToken(parser);
                     printSyntacticError(CodeBlockEndError, parser);
                     break;
             }
 
-            re = makeBlockCode(curly, code_list, prefix, parser->reader->line, NULL, NULL);
+            re = makeBlockCode(curly, code_list, prefix, parser->reader->line, nullptr, nullptr);
             break;
         case TK_ERROR:
-            return NULL;
+            return nullptr;
         default:
             printSyntacticError(CodeBlockEndError, parser);
-            return NULL;
+            return nullptr;
     }
 
-    if (re == NULL)
+    if (re == nullptr)
         printSyntacticError(MakeCodeFail, parser);
     return re;
 }
 
-static af_Code *codePrefix(size_t deep, af_Parser *parser) {
+static af_Code *codePrefix(size_t deep, af_Parser *parser) {  // NOLINT
     char ch = NUL;
     getToken(parser);
     if (parser->syntactic->token != TK_PREFIX) {
@@ -139,18 +139,18 @@ static af_Code *codePrefix(size_t deep, af_Parser *parser) {
     return code(deep, ch, parser);
 }
 
-static af_Code *codeList(size_t deep, af_Parser *parser) {
-    af_Code *re = NULL;
+static af_Code *codeList(size_t deep, af_Parser *parser) {  // NOLINT
+    af_Code *re = nullptr;
     af_Code **pre = &re;
     af_Code *code_list;
 
-    while (1) {
+    while (true) {
         getToken(parser);
         switch (parser->syntactic->token) {
             case TK_PREFIX:
                 goBackToken(parser);
                 code_list = codePrefix(deep, parser);
-                if (code_list != NULL)
+                if (code_list != nullptr)
                     pre = &(pushCode(pre, code_list)->next);
                 break;
 
@@ -161,12 +161,12 @@ static af_Code *codeList(size_t deep, af_Parser *parser) {
             case TK_LC:
                 goBackToken(parser);
                 code_list = code(deep, NUL, parser);
-                if (code_list != NULL)
+                if (code_list != nullptr)
                     pre = &(pushCode(pre, code_list)->next);
                 break;
             case TK_ERROR:
                 freeAllCode(re);
-                return NULL;
+                return nullptr;
             default: /* 结束 */
                 goBackToken(parser);
                 return re;
@@ -175,7 +175,7 @@ static af_Code *codeList(size_t deep, af_Parser *parser) {
 }
 
 static af_Code *codeListEnd(af_Parser *parser) {
-    af_Code *re = NULL;
+    af_Code *re = nullptr;
     af_Code **pre = &re;
     af_Code *code_list;
 
@@ -199,18 +199,18 @@ static af_Code *codeListEnd(af_Parser *parser) {
                     break;  // 正常结束
                 case TK_ERROR:
                     freeAllCode(re);
-                    return NULL;
+                    return nullptr;
                 default:
                     printSyntacticError(CodeListEndError, parser);
                     freeAllCode(re);
-                    return NULL;
+                    return nullptr;
             }
             break;
         case TK_ERROR:
-            return NULL;
+            return nullptr;
         default:
             printSyntacticError(CodeListStartError, parser);
-            return NULL;
+            return nullptr;
     }
 
     return re;
@@ -220,14 +220,14 @@ 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 NULL;
+        return nullptr;
     }
 
-    if (code != NULL) {
-        if (parser->reader->file != NULL)
-            code->path = pathCopy(parser->reader->file);
+    if (code != nullptr) {
+        if (parser->reader->file != nullptr)
+            code->path = strCopy(parser->reader->file);
         else
-            code->path = pathCopy("unknown.aun");
+            code->path = strCopy("unknown.aun");
     }
 
     return code;

src/core/thread.c → src/core/thread.cpp

@@ -1,7 +1,7 @@
-#include "__env.h"
-#include "__run.h"
-#include "core_init.h"
-#include "thread.h"
+#include "__env.hpp"
+#include "__run.hpp"
+#include "core_init.hpp"
+#include "thread.hpp"
 
 struct EnvCode {
     af_Environment *env;
@@ -20,33 +20,33 @@ static void *runThread(void *ec);
  */
 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){
-    af_Environment *base = env->base;
-    af_Environment *new = deriveEnvironment(derive_tmp, derive_guardian, derive_lr, enable, base);
+    auto base = env->base;
+    auto new_env = deriveEnvironment(derive_tmp, derive_guardian, derive_lr, enable, base);
 
-    if (vs == NULL) {
+    if (vs == nullptr) {
         af_Object *obj = getGlobal(env);
         vs = makeVarSpace(obj, 3, 3, 3, env);
         gc_delObjectReference(obj, env);
     }
 
-    new->activity->run_varlist = pushVarList(vs, new->activity->run_varlist);
-    new->activity->count_run_varlist++;
+    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, code, not_copy_code);
-    return new;
+        startRunThread_(new_env, code, not_copy_code);
+    return new_env;
 }
 
 
 void startRunThread_(af_Environment *env, af_Code *code, bool not_copy_code){
-    struct EnvCode *ec = calloc(1, sizeof(struct EnvCode));
+    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, NULL, runThread, ec);
+    pthread_create(&id, nullptr, runThread, ec);
     pthread_detach(id);
 }
 
@@ -70,5 +70,5 @@ static void *runThread(void *ec) {
     freeEnvironment(env);
 
     writeInfoLog(aFunCoreLogger, "Thread end");
-    return NULL;
+    return nullptr;
 }

src/core/var.c → src/core/var.cpp

@@ -1,15 +1,15 @@
-#include "__var.h"
-#include "core_init.h"
-#include "tool.h"
+#include "__var.hpp"
+#include "core_init.hpp"
+#include "tool.hpp"
 
 
 /* VarNode 创建与释放 */
-static af_VarNode *makeVarNode(af_Object *obj, char *id);
+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, char *id);
+static af_VarNode *findVarNode_(af_Var *var, const char *id);
 
 /* VarCup 创建与释放 */
 static af_VarCup *makeVarCup(af_Var *var);
@@ -17,41 +17,41 @@ static af_VarCup *freeVarCup(af_VarCup *vp);
 static void freeAllVarCup(af_VarCup *vp);
 
 /* VarSpace 寻值函数 */
-static af_Var *findVarFromVarSpaceByIndex(time33_t index, char *name, af_VarSpace *vs);
+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, char *id) {
-    af_VarNode *vn = calloc(1, sizeof(af_VarNode));
-    if (id != NULL)
+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) {
-    af_VarNode *next = vn->next;
+    auto next = vn->next;
     free(vn->id);
     free(vn);
     return next;
 }
 
 static void freeAllVarNode(af_VarNode *vn) {
-    while (vn != NULL)
+    while (vn != nullptr)
         vn = freeVarNode(vn);
 }
 
-af_Var *makeVar(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_Environment *env){
-    af_VarNode *vn = makeVarNode(obj, NULL);
-    af_Var *var = calloc(1, sizeof(af_Var));
+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, NULL);
+    pthread_rwlock_init(&var->lock, nullptr);
     gc_addVar(var, env->base);
     return var;
 }
@@ -71,23 +71,23 @@ void freeVar(af_Var *var, af_Environment *env){
  * @param id
  * @return
  */
-static af_VarNode *findVarNode_(af_Var *var, char *id) {
-    af_VarNode *vn = var->vn->next;
+static af_VarNode *findVarNode_(af_Var *var, const char *id) {
+    auto vn = var->vn->next;
 
-    if (id == NULL)
+    if (id == nullptr)
         return var->vn;
 
-    for (NULL; vn != NULL; vn = vn->next) {
+    for(NULL; vn != nullptr; vn = vn->next) {
         if (EQ_STR(vn->id, id))
             return vn;
     }
-    return NULL;
+    return nullptr;
 }
 
-void addVarNode(af_Var *var, af_Object *obj, char *id) {
-    af_VarNode *vn = makeVarNode(obj, id);
+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=NULL
+    vn->next = var->vn->next;  // 第一个 vn 必须为 id=nullptr
     var->vn->next = vn;
     pthread_rwlock_unlock(&var->lock);
 }
@@ -100,11 +100,11 @@ void addVarNode(af_Var *var, af_Object *obj, char *id) {
  * @param id
  * @return
  */
-af_Object *findVarNode(af_Var *var, char *id, af_Environment *env){
+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 = NULL;
-    if (vn != NULL) {
+    af_Object *obj = nullptr;
+    if (vn != nullptr) {
         obj = vn->obj;
         gc_addObjectReference(obj, env);
     }
@@ -113,7 +113,7 @@ af_Object *findVarNode(af_Var *var, char *id, af_Environment *env){
 }
 
 static af_VarCup *makeVarCup(af_Var *var) {
-    af_VarCup *vp = calloc(1, sizeof(af_VarCup));
+    auto vp = calloc(1, af_VarCup);
     vp->var = var;
     return vp;
 }
@@ -125,19 +125,19 @@ static af_VarCup *freeVarCup(af_VarCup *vp) {
 }
 
 static void freeAllVarCup(af_VarCup *vp) {
-    while (vp != NULL)
+    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 != NULL, aFunCoreLogger, 1, "makeVarSpace error");
-    af_VarSpace *vs = calloc(1, sizeof(af_VarSpace));
+    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, NULL);
+    pthread_rwlock_init(&vs->lock, nullptr);
     gc_addVarSpace(vs, env->base);
     return vs;
 }
@@ -151,15 +151,15 @@ void freeVarSpace(af_VarSpace *vs, af_Environment *env) {
 }
 
 af_VarList *makeVarSpaceList(af_VarSpace *vs) {
-    af_VarList *vsl = calloc(1, sizeof(af_VarList));
+    auto vsl = calloc(1, af_VarList);
     vsl->vs = vs;
     return vsl;
 }
 
 af_VarList *copyVarSpaceList(af_VarList *vsl) {
-    af_VarList *base = NULL;
+    af_VarList *base = nullptr;
     af_VarList **pvsl = &base;
-    for (NULL; vsl != NULL; vsl = vsl->next, pvsl = &((*pvsl)->next))
+    for(NULL; vsl != nullptr; vsl = vsl->next, pvsl = &((*pvsl)->next))
         *pvsl = makeVarSpaceList(vsl->vs);
     return base;
 }
@@ -171,19 +171,19 @@ static af_VarList *freeVarSpaceList(af_VarList *vsl){
 }
 
 void freeAllVarSpaceList(af_VarList *vsl){
-    while (vsl != NULL)
+    while (vsl != nullptr)
         vsl = freeVarSpaceList(vsl);
 }
 
 af_VarSpace *getVarSpaceFromList(af_VarList *vsl) {
-    if (vsl != NULL)
+    if (vsl != nullptr)
         return vsl->vs;
-    return NULL;
+    return nullptr;
 }
 
 bool freeVarSpaceListCount(size_t count, af_VarList *vsl) {
     for (size_t i = count; i > 0; i--) {
-        if (vsl == NULL)  // 发生了错误
+        if (vsl == nullptr)  // 发生了错误
             return false;
         vsl = freeVarSpaceList(vsl);
     }
@@ -199,23 +199,23 @@ bool freeVarSpaceListCount(size_t count, af_VarList *vsl) {
 static bool checkVarSpaceDefinePermissions(af_Object *visitor, af_VarSpace *vs){
     char p = vs->permissions[2];  // 默认外部权限
 
-    af_ObjectData *belong_data = NULL;
-    if (vs->belong != NULL) {
+    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 = NULL;
-    if (visitor != NULL) {
+    af_ObjectData *visitor_data;
+    if (visitor != nullptr) {
         pthread_rwlock_rdlock(&visitor->lock);
         visitor_data = visitor->data;
         pthread_rwlock_unlock(&visitor->lock);
     }
 
-    if (vs->belong == NULL || (visitor != NULL && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
+    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
         p = vs->permissions[0];
-    else if (visitor != NULL && checkPosterity(vs->belong, visitor))  // 应用后代权限
+    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
         p = vs->permissions[1];
 
     return p == 2 || p == 3;
@@ -242,7 +242,7 @@ bool addVarToVarSpace(af_Var *var, af_Object *visitor, af_VarSpace *vs, af_Envir
     if (!checkVarSpaceDefinePermissions(visitor, vs))
         goto RETURN_FALSE;
 
-    for (NULL; *pCup != NULL; pCup = &((*pCup)->next)) {
+    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);
@@ -270,7 +270,7 @@ RETURN_FALSE:
  * 调用 addVarToVarSpace
  * 注意: 必须保证 VarSpace被 gc 引用
  */
-bool makeVarToVarSpace(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_VarSpace *vs,
+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))
@@ -286,7 +286,7 @@ bool makeVarToVarSpace(char *name, char p_self, char p_posterity, char p_externa
  * 调用 addVarToVarSpace
  */
 bool addVarToVarSpaceList(af_Var *var, af_Object *visitor, af_VarList *vsl, af_Environment *env){
-    for (NULL; vsl != NULL; vsl = vsl->next) {
+    for(NULL; vsl != nullptr; vsl = vsl->next) {
         if (!vsl->vs->is_protect)
             return addVarToVarSpace(var, visitor, vsl->vs, env);
     }
@@ -299,7 +299,7 @@ bool addVarToVarSpaceList(af_Var *var, af_Object *visitor, af_VarList *vsl, af_E
  * 调用 addVarToVarSpaceList -> addVarToVarSpace
  * 注意: 必须保证 VarSpace被 gc 引用
  */
-bool makeVarToVarSpaceList(char *name, char p_self, char p_posterity, char p_external, af_Object *obj,
+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))
@@ -314,7 +314,9 @@ bool makeVarToVarSpaceList(char *name, char p_self, char p_posterity, char p_ext
  * 否则返回true
  * 调用 addVarToVarSpace
  */
-bool makeVarToProtectVarSpace(char *name, char p_self, char p_posterity, char p_external, af_Object *obj, af_Environment *env){
+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;
@@ -344,7 +346,7 @@ bool addVarToProtectVarSpace(af_Var *var, af_Environment *env) {
     env->protect->is_protect = false;
     pthread_rwlock_unlock(&env->protect->lock);
 
-    bool re = addVarToVarSpace(var, NULL, env->protect, env);
+    bool re = addVarToVarSpace(var, nullptr, env->protect, env);
 
     pthread_rwlock_wrlock(&env->protect->lock);
     env->protect->is_protect = is_protect;
@@ -363,23 +365,23 @@ bool addVarToProtectVarSpace(af_Var *var, af_Environment *env) {
 static bool checkVarSpaceDelPermissions(af_Object *visitor, af_VarSpace *vs) {
     char p = vs->permissions[2];  // 默认外部权限
 
-    af_ObjectData *belong_data = NULL;
-    if (vs->belong != NULL) {
+    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 = NULL;
-    if (visitor != NULL) {
+    af_ObjectData *visitor_data;
+    if (visitor != nullptr) {
         pthread_rwlock_rdlock(&visitor->lock);
         visitor_data = visitor->data;
         pthread_rwlock_unlock(&visitor->lock);
     }
 
-    if (vs->belong == NULL || (visitor != NULL && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
+    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
         p = vs->permissions[0];
-    else if (visitor != NULL && checkPosterity(vs->belong, visitor))  // 应用后代权限
+    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
         p = vs->permissions[1];
 
     return p == 1 || p == 3;
@@ -391,7 +393,7 @@ static bool checkVarSpaceDelPermissions(af_Object *visitor, af_VarSpace *vs) {
  * 若空间被保护, 权限错误或已存在同名Var则返回false不作修改
  * 否则返回true
  */
-bool delVarFromVarSpace(char *name, af_Object *visitor, af_VarSpace *vs) {
+bool delVarFromVarSpace(const char *name, af_Object *visitor, af_VarSpace *vs) {
     time33_t index = time33(name) % VAR_HASHTABLE_SIZE;
 
     pthread_rwlock_wrlock(&vs->lock);
@@ -403,7 +405,7 @@ bool delVarFromVarSpace(char *name, af_Object *visitor, af_VarSpace *vs) {
     if (!checkVarSpaceDelPermissions(visitor, vs))
         goto RETRUN_FALSE;
 
-    for (NULL; *pCup != NULL; pCup = &((*pCup)->next)) {
+    for(NULL; *pCup != nullptr; pCup = &((*pCup)->next)) {
         pthread_rwlock_wrlock(&(*pCup)->var->lock);
 
         if (EQ_STR((*pCup)->var->name, name)) {
@@ -428,7 +430,7 @@ RETRUN_FALSE:
  * 否则返回true
  * 调用delVarFromVarSpace
  */
-bool delVarFromVarList(char *name, af_Object *visitor, af_VarList *vsl) {
+bool delVarFromVarList(const char *name, af_Object *visitor, af_VarList *vsl) {
     return delVarFromVarSpace(name, visitor, vsl->vs);
 }
 
@@ -437,9 +439,9 @@ bool delVarFromVarList(char *name, af_Object *visitor, af_VarList *vsl) {
  * 目标: 根据指定的index, 在VarSpace中搜索var
  * 权限检查交给 findVarFromVarSpace 和 findVarFromVarList
  */
-static af_Var *findVarFromVarSpaceByIndex(time33_t index, char *name, af_VarSpace *vs) {
+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 != NULL; cup = cup->next) {
+    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)) {
@@ -452,7 +454,7 @@ static af_Var *findVarFromVarSpaceByIndex(time33_t index, char *name, af_VarSpac
         pthread_rwlock_unlock(&cup->var->lock);
     }
     pthread_rwlock_unlock(&vs->lock);
-    return NULL;
+    return nullptr;
 }
 
 /**
@@ -469,23 +471,23 @@ static bool checkVarReadPermissions(af_Var *var, af_Object *visitor, af_VarSpace
     pthread_rwlock_rdlock(&vs->lock);
     pthread_rwlock_rdlock(&var->lock);
 
-    af_ObjectData *belong_data = NULL;
-    if (vs->belong != NULL) {
+    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 = NULL;
-    if (visitor != NULL) {
+    af_ObjectData *visitor_data;
+    if (visitor != nullptr) {
         pthread_rwlock_rdlock(&visitor->lock);
         visitor_data = visitor->data;
         pthread_rwlock_unlock(&visitor->lock);
     }
 
-    if (vs->belong == NULL || (visitor != NULL && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
+    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
         p = var->permissions[0];
-    else if (visitor != NULL && checkPosterity(vs->belong, visitor))  // 应用后代权限
+    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
         p = var->permissions[1];
 
     pthread_rwlock_unlock(&vs->lock);
@@ -498,14 +500,14 @@ static bool checkVarReadPermissions(af_Var *var, af_Object *visitor, af_VarSpace
  * 目标: 在VarSpace中搜索var
  * 调用: findVarFromVarSpaceByIndex
  */
-af_Var *findVarFromVarSpace(char *name, af_Object *visitor, af_VarSpace *vs){
+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 == NULL)
-        return NULL;
+    if (var == nullptr)
+        return nullptr;
 
     if (checkVarReadPermissions(var, visitor, vs))
         return var;
-    return NULL;
+    return nullptr;
 }
 
 /*
@@ -513,20 +515,19 @@ af_Var *findVarFromVarSpace(char *name, af_Object *visitor, af_VarSpace *vs){
  * 目标: 在VarSpaceListNode中搜索var
  * 调用: findVarFromVarSpaceByIndex
  */
-af_Var *findVarFromVarList(char *name, af_Object *visitor, af_VarList *vsl) {
+af_Var *findVarFromVarList(const char *name, af_Object *visitor, af_VarList *vsl) {
     time33_t index = time33(name) % VAR_HASHTABLE_SIZE;
-    af_Var *var = NULL;
 
-    for (NULL; vsl != NULL; vsl = vsl->next) {
-        var = findVarFromVarSpaceByIndex(index, name, vsl->vs);
-        if (var != NULL) {
+    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 NULL;
+            return nullptr;
         }
     }
 
-    return NULL;
+    return nullptr;
 }
 
 /**
@@ -540,24 +541,24 @@ af_Var *findVarFromVarList(char *name, af_Object *visitor, af_VarList *vsl) {
 static bool checkVarWritePermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs){
     char p = var->permissions[2];  // 默认外部权限
 
-    af_ObjectData *belong_data = NULL;
-    if (vs->belong != NULL) {
+    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 = NULL;
-    if (visitor != NULL) {
+    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 == NULL || (visitor != NULL && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
+    if (vs->belong == nullptr || (visitor != nullptr && belong_data == visitor_data))  // (无权限设定或ObjectData匹配) 应用自身权限
         p = var->permissions[0];
-    else if (visitor != NULL && checkPosterity(vs->belong, visitor))  // 应用后代权限
+    else if (visitor != nullptr && checkPosterity(vs->belong, visitor))  // 应用后代权限
         p = var->permissions[1];
     pthread_rwlock_unlock(&vs->lock);
 
@@ -569,9 +570,9 @@ static bool checkVarWritePermissions(af_Var *var, af_Object *visitor, af_VarSpac
  * 目标: 在VarSpace中搜索var并修改其值
  * 调用: findVarFromVarSpaceByIndex
  */
-bool setVarToVarSpace(char *name, af_Object *obj, af_Object *visitor, af_VarSpace *vs){
+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 == NULL)
+    if (var == nullptr)
         return false;
 
     pthread_rwlock_wrlock(&vs->lock);
@@ -593,13 +594,13 @@ bool setVarToVarSpace(char *name, af_Object *obj, af_Object *visitor, af_VarSpac
  * 目标: 在VarSpaceListNode中搜索var并修改其值
  * 调用: findVarFromVarSpaceByIndex
  */
-bool setVarToVarList(char *name, af_Object *obj, af_Object *visitor, af_VarList *vsl) {
+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 = NULL;
+    af_Var *var;
 
-    for (NULL; vsl != NULL; vsl = vsl->next) {
+    for(NULL; vsl != nullptr; vsl = vsl->next) {
         var = findVarFromVarSpaceByIndex(index, name, vsl->vs);
-        if (var != NULL) {
+        if (var != nullptr) {
             pthread_rwlock_wrlock(&vsl->vs->lock);
             if (checkVarWritePermissions(var, visitor, vsl->vs)) {
                 pthread_rwlock_unlock(&vsl->vs->lock);
@@ -627,9 +628,9 @@ bool setVarToVarList(char *name, af_Object *obj, af_Object *visitor, af_VarList
  */
 af_VarList *pushNewVarList(af_Object *belong, af_VarList *base, af_Environment *env){
     af_VarSpace *vs = makeVarSpace(belong, 3, 2, 0, env);
-    af_VarList *new = makeVarSpaceList(vs);
-    new->next = base;
-    return new;
+    af_VarList *new_vs = makeVarSpaceList(vs);
+    new_vs->next = base;
+    return new_vs;
 }
 
 /**
@@ -640,29 +641,29 @@ af_VarList *pushNewVarList(af_Object *belong, af_VarList *base, af_Environment *
  * @return
  */
 af_VarList *pushProtectVarList(af_VarList *base, af_Environment *env){
-    af_VarList *new = makeVarSpaceList(getProtectVarSpace(env));
-    new->next = base;
-    return new;
+    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 = makeVarSpaceList(vs);
-    new->next = base;
-    return new;
+    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 = NULL;
-    if (vs->belong != NULL) {
+    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 = NULL;
-    if (visitor != NULL) {
+    af_ObjectData *visitor_data = nullptr;
+    if (visitor != nullptr) {
         pthread_rwlock_rdlock(&visitor->lock);
         visitor_data = visitor->data;
         pthread_rwlock_unlock(&visitor->lock);
@@ -670,7 +671,7 @@ void setVarPermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs, char p_
 
     pthread_rwlock_unlock(&vs->lock);
 
-    if (belong_data != NULL && belong_data != visitor_data)
+    if (belong_data != nullptr && belong_data != visitor_data)
         return;
 
     pthread_rwlock_wrlock(&var->lock);
@@ -683,15 +684,15 @@ void setVarPermissions(af_Var *var, af_Object *visitor, af_VarSpace *vs, char p_
 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 = NULL;
-    if (vs->belong != NULL) {
+    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 = NULL;
-    if (visitor != NULL) {
+    af_ObjectData *visitor_data = nullptr;
+    if (visitor != nullptr) {
         pthread_rwlock_rdlock(&visitor->lock);
         visitor_data = visitor->data;
         pthread_rwlock_unlock(&visitor->lock);
@@ -699,7 +700,7 @@ void setVarSpacePermissions(af_Object *visitor, af_VarSpace *vs, char p_self, ch
 
     pthread_rwlock_unlock(&vs->lock);
 
-    if (belong_data != NULL && belong_data != visitor_data)
+    if (belong_data != nullptr && belong_data != visitor_data)
         return;
 
     vs->permissions[0] = p_self;
@@ -718,21 +719,21 @@ bool setVarSpaceProtect(af_Object *visitor, af_VarSpace *vs, bool protect) {
     pthread_rwlock_wrlock(&vs->lock);
     bool re = vs->is_protect;
 
-    af_ObjectData *belong_data = NULL;
-    if (vs->belong != NULL) {
+    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 = NULL;
-    if (visitor != NULL) {
+    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 != NULL && belong_data != visitor_data) {
+    if (belong_data != nullptr && belong_data != visitor_data) {
         pthread_rwlock_unlock(&vs->lock);
         return re;
     }

src/main.c → src/main.cpp

@@ -1,9 +1,9 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "aFun.h"
-#include "main.h"
-#include "main_run.h"
-#include "main_build.h"
+#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')
@@ -32,17 +32,17 @@ 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 = NULL;
+static const char *name = nullptr;
 
 static int mainHelp(ff_FFlags *ff);
-static void printVersion(void);
-static void printHelp(void);
+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 = NULL;
+char *base_path = nullptr;
 static Logger aFunlangLogger_;
 Logger *aFunlangLogger = &aFunlangLogger_;
 static bool tty_stdin = false;
@@ -53,58 +53,59 @@ void freeBaseName(void *_) {
 
 #ifdef aFunWIN32_NO_CYGWIN
 
-int argc__ = 0;
-char **argv__ = NULL;
+int argc_s = 0;
+char **argv_s = nullptr;
 
 void convertArgs(int argc, char *argv_ansi[]) {
-    argc__ = argc;
-    argv__ = calloc((size_t)argc, sizeof(char *));
+    argc_s = argc;
+    argv_s = calloc((size_t)argc, char *);
     for(int i = 0; i < argc; i++) {
-        if (convertMultiByte(argv__ + i, argv_ansi[i], CP_ACP, CP_UTF8) == 0) {
+        if (convertMultiByte(argv_s + i, argv_ansi[i], CP_ACP, CP_UTF8) == 0) {
             fputs_std_("参数转换错误", stderr);
             exit(EXIT_FAILURE);
         }
     }
 }
 
-void convertArgsFree(void) {
-    for(int i = 0; i < argc__; i++)
-        free(argv__[i]);
-    free(argv__);
+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__;
+    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 == NULL)
-        goto INIT_ERROR;
-    aFunAtExit(freeBaseName, NULL);
+    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
-                         .log_asyn=true,
-                         .buf=&main_buf,
     };
 
     ff_FFlags *ff = ff_initFFlags(argc, argv, true, false, stderr, aFunlang_exe);
-    if (ff == NULL)
+    if (ff == nullptr)
         aFunExit(aFunExitFail);
 
     if (!aFunInit(&info)) {
-INIT_ERROR:
         printf_stderr(0, "aFunlang init error.");
         aFunExit(aFunExitFail);
     }
@@ -114,7 +115,7 @@ INIT_ERROR:
     writeDebugLog(aFunlangLogger, "aFunlang-exe init success: %s", (tty_stdin ? "tty" : "no-tty"));
 
     int exit_code = EXIT_SUCCESS;
-    char *child = ff_getChild(ff);
+    const char *child = ff_getChild(ff);
     name = *argv;  // 获取第一个参数为name
 
     if (EQ_STR(child, "cl"))
@@ -131,7 +132,7 @@ INIT_ERROR:
     aFunExit(exit_code);
 }
 
-static void printVersion(void) {
+static void printVersion() {
     /* Version的显示不被翻译, 因为它通常还需要被其他程序读取而进行处理, 必须保证一致性 */
     printf_stdout(0, "aFunlang at  %s\n", name);
     printf_stdout(0, "aFunlang dir %s\n", base_path);
@@ -139,13 +140,13 @@ static void printVersion(void) {
     fputs_stdout(aFunDescription"\n");
 }
 
-static void printWelcomeInfo(void) {
+static void printWelcomeInfo() {
     printf_stdout(0, "aFunlang " aFunVersion " %s (" __DATE__ ", " __TIME__ ")\n", HT_aFunGetText(command_line_n, "CommandLine"));
-    fputs_stdout("["compilerID"] on "systemName"\n");
+    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(void) {
+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>"));
 }
@@ -161,12 +162,12 @@ static void printError(ff_FFlags *ff) {
 }
 
 static int mainHelp(ff_FFlags *ff) {
-    char *text = NULL;
+    char *text = nullptr;
     int mark;
     bool have_opt = false;
     /* 无信号处理 */
 
-    while (1) {
+    while (true) {
         mark = ff_getopt(&text, ff);
 
         switch (mark) {
@@ -196,7 +197,7 @@ out:
 
 static int mainRun(ff_FFlags *ff) {
     int exit_code;
-    char **argv = NULL;
+    char **argv = nullptr;
     int argc = ff_get_process_argv(&argv, ff);
     af_Environment *env;
     aFunRunInfo ri = {.signal=true};
@@ -206,7 +207,7 @@ static int mainRun(ff_FFlags *ff) {
         /* 进入命令行模式 */
         if (!tty_stdin)
             return 0;
-        env = creatAFunEnvironment(0, NULL);
+        env = creatAFunEnvironment(0, nullptr);
         printWelcomeInfo();
         do {
             if (ferror(stdin) || feof(stdin)) {  // 错误应在实际程序中处理, 若在此仍处于错误状态则直接返回
@@ -231,8 +232,8 @@ static int mainRun(ff_FFlags *ff) {
 }
 
 static RunList *getRunList(ff_FFlags *ff, bool *command_line, bool *save_aub) {
-    char *text = NULL;
-    RunList *run_list = NULL;
+    char *text = nullptr;
+    RunList *run_list = nullptr;
     RunList **prl = &run_list;
     int mark;
     bool import = true;
@@ -240,7 +241,7 @@ static RunList *getRunList(ff_FFlags *ff, bool *command_line, bool *save_aub) {
     *command_line = true;
     *save_aub = true;
 
-    while (1) {
+    while (true) {
         mark = ff_getopt(&text, ff);
         switch (mark) {
             case 'e':
@@ -250,10 +251,10 @@ static RunList *getRunList(ff_FFlags *ff, bool *command_line, bool *save_aub) {
                 prl = pushRunList(makeFileRunList(text, import), prl);
                 break;
             case 's':
-                prl = pushRunList(makeFileSourceRunList(text, import), prl);
+                prl = pushRunList(makeFileSourceRunList(text), prl);
                 break;
             case 'b':
-                prl = pushRunList(makeFileByteRunList(text, import), prl);
+                prl = pushRunList(makeFileByteRunList(text), prl);
                 break;
             case 'n':
                 *command_line = false;
@@ -273,7 +274,7 @@ static RunList *getRunList(ff_FFlags *ff, bool *command_line, bool *save_aub) {
                 *command_line = false;  // 命令行也不启动
                 printError(ff);
                 freeAllRunList(run_list);
-                return NULL;
+                return nullptr;
         }
     }
 
@@ -289,7 +290,7 @@ static int mainCL(ff_FFlags *ff) {
     int exit_code;
     RunList *rl = getRunList(ff, &command_line, &save_aub);
 
-    if (rl == NULL && !command_line) {
+    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;
@@ -300,7 +301,7 @@ static int mainCL(ff_FFlags *ff) {
     while (ff_getopt_wild_after(&text, ff))
         argc++;
 
-    char **argv = calloc(argc, sizeof(char *));
+    char **argv = calloc(argc, char *);
     for (int i = 0; ff_getopt_wild_after(&text, ff); i++)
         argv[i] = text;
 
@@ -308,8 +309,8 @@ static int mainCL(ff_FFlags *ff) {
     aFunRunInfo ri = {.signal=true};
     defineRunEnv(&ri);  // 由aFunCore提前接管
 
-    if (rl != NULL)
-        runCodeFromRunList(rl, NULL, save_aub, env);
+    if (rl != nullptr)
+        runCodeFromRunList(rl, nullptr, save_aub, env);
 
     if (tty_stdin && command_line && isCoreExit(env) != 1) {
         printWelcomeInfo();
@@ -334,19 +335,19 @@ static int mainCL(ff_FFlags *ff) {
 }
 
 static int mainBuild(ff_FFlags *ff) {
-    char *text = NULL;
-    char *out_put = NULL;
-    char *path = NULL;
+    char *text = nullptr;
+    char *out_put = nullptr;
+    char *path = nullptr;
     bool force = false;
     int mark;
     int exit_code = 0;
 
-    while (1) {
+    while (true) {
         mark = ff_getopt(&text, ff);
 
         switch (mark) {
             case 'o':
-                if (path != NULL) {
+                if (path != nullptr) {
                     writeErrorLog(aFunlangLogger, "Build argument conflict");
                     printf_stderr(0, "%s (--out, --path)\n", HT_aFunGetText(arg_conflict_n, "Argument conflict"));
                     goto error;
@@ -354,7 +355,7 @@ static int mainBuild(ff_FFlags *ff) {
                 out_put = text;
                 break;
             case 'p':
-                if (out_put != NULL) {
+                if (out_put != nullptr) {
                     writeErrorLog(aFunlangLogger, "Build argument conflict");
                     printf_stderr(0, "%s (--out, --path)\n", HT_aFunGetText(arg_conflict_n, ""));
                     goto error;
@@ -372,8 +373,8 @@ static int mainBuild(ff_FFlags *ff) {
     }
 
 out:
-    if (out_put != NULL) {
-        FilePath in = NULL;
+    if (out_put != nullptr) {
+        FilePath in;
 
         /* 如果没有参数 */
         if (!ff_getopt_wild(&text, ff)) {
@@ -391,7 +392,7 @@ out:
         }
 
         return buildFileOutput(out_put, in, force);
-    } else if (path != NULL) {
+    } else if (path != nullptr) {
         while (ff_getopt_wild(&text, ff) && exit_code == 0)
             exit_code = buildFileToPath(path, text, force);
         return exit_code;

src/main_build.c → src/main_build.cpp

@@ -1,5 +1,5 @@
-#include "aFun.h"
-#include "main_build.h"
+#include "aFun.hpp"
+#include "main_build.hpp"
 
 int buildFileOutput(FilePath out, FilePath in, bool force) {
     if (!force) {

src/main_build.h → src/main_build.hpp

@@ -1,6 +1,6 @@
 #ifndef AFUN_MAIN_BUILD_H_
 #define AFUN_MAIN_BUILD_H_
-#include "main.h"
+#include "main.hpp"
 
 int buildFileOutput(FilePath out, FilePath in, bool force);
 int buildFileToPath(FilePath path, FilePath in, bool force);

src/main_run.c → src/main_run.cpp

@@ -1,9 +1,9 @@
-#include "aFun.h"
-#include "main_run.h"
+#include "aFun.hpp"
+#include "main_run.hpp"
 
 
 static RunList *makeRunList(bool import){
-    RunList *run_list = calloc(1, sizeof(RunList));
+    auto run_list = calloc(1, RunList);
     run_list->import = import;
     return run_list;
 }
@@ -19,7 +19,7 @@ static RunList *freeRunList(RunList *rl) {
 }
 
 void freeAllRunList(RunList *rl) {
-    while(rl != NULL)
+    while(rl != nullptr)
         rl = freeRunList(rl);
 }
 
@@ -30,13 +30,13 @@ RunList *makeFileRunList(FilePath file, bool import){
     return rl;
 }
 
-RunList *makeFileSourceRunList(FilePath file, bool import){
+RunList *makeFileSourceRunList(FilePath file){
     RunList *rl = makeFileRunList(file, true);
     rl->type = rl_file_s;
     return rl;
 }
 
-RunList *makeFileByteRunList(FilePath file, bool import){
+RunList *makeFileByteRunList(FilePath file){
     RunList *rl = makeFileRunList(file, true);
     rl->type = rl_file_b;
     return rl;
@@ -50,10 +50,10 @@ RunList *makeStringRunList(char *string, bool import){
 }
 
 RunList **pushRunList(RunList *rl, RunList **base) {
-    while (*base != NULL)
+    while (*base != nullptr)
         base = &((*base)->next);
     *base = rl;
-    while (*base != NULL)
+    while (*base != nullptr)
         base = &((*base)->next);
     return base;
 }
@@ -61,7 +61,7 @@ RunList **pushRunList(RunList *rl, RunList **base) {
 int runCodeFromRunList(RunList *run_list, RunList **bak, bool save_afb, af_Environment *env) {
     int exit_code = 0;
 
-    for (NULL; run_list != NULL; run_list = run_list->next) {
+    for(NULL; run_list != nullptr; run_list = run_list->next) {
         int mode = run_list->import ? 1 : 0;
         switch (run_list->type) {
             case rl_string:
@@ -74,14 +74,14 @@ int runCodeFromRunList(RunList *run_list, RunList **bak, bool save_afb, af_Envir
                 exit_code = runCodeFromFileByte(run_list->file, mode, env);
                 break;
             case rl_file_s:
-                exit_code = runCodeFromFileSource(run_list->file, save_afb, NULL, mode, env);
+                exit_code = runCodeFromFileSource(run_list->file, save_afb, nullptr, mode, env);
                 break;
             default:
                 break;
         }
     }
 
-    if (bak != NULL)
+    if (bak != nullptr)
         *bak = run_list;
     return exit_code;
 }

src/main_run.h → src/main_run.hpp

@@ -1,15 +1,17 @@
 #ifndef AFUN_MAIN_RUN_H_
 #define AFUN_MAIN_RUN_H_
-#include "main.h"
+#include "main.hpp"
+
+enum RunListType {
+    rl_file,
+    rl_file_s,
+    rl_file_b,
+    rl_string
+};
 
 typedef struct RunList RunList;
 struct RunList {
-    enum RunListType {
-        rl_file,
-        rl_file_s,
-        rl_file_b,
-        rl_string
-    } type;
+    enum RunListType type;
 
     union {
         FilePath file;
@@ -21,8 +23,8 @@ struct RunList {
 };
 
 RunList *makeFileRunList(FilePath file, bool import);
-RunList *makeFileByteRunList(FilePath file, bool import);
-RunList *makeFileSourceRunList(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);

src/runtime/CMakeLists.txt

@@ -1,27 +1,27 @@
 file(GLOB source
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.c)
+     ${CMAKE_CURRENT_LIST_DIR}/*.cpp)
 
 file(GLOB source_tool
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*/*.c)
+     ${CMAKE_CURRENT_LIST_DIR}/*/*.cpp)
 
 file(GLOB private_h
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*.h)
+     ${CMAKE_CURRENT_LIST_DIR}/*.hpp)
 
 file(GLOB private_tool_h
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/*/*.h)
+     ${CMAKE_CURRENT_LIST_DIR}/*/*.hpp)
 
 file(GLOB private_h_core
      LIST_DIRECTORIES FALSE
-     ${CMAKE_CURRENT_LIST_DIR}/../core/*.h)  # 需要使用 core 的特定头文件 (高级开发)
+     ${CMAKE_CURRENT_LIST_DIR}/../core/*.hpp)  # 需要使用 core 的特定头文件 (高级开发)
 
 file(GLOB public_h
      LIST_DIRECTORIES FALSE
      RELATIVE "${build_include_runtime}"
-     "${build_include_runtime}/*.h")
+     "${build_include_runtime}/*.hpp")
 
 set(public_h_build)
 set(public_h_install)

src/runtime/__aFunlang.h → src/runtime/__aFunlang.hpp

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

src/runtime/__cycle_obj.h → src/runtime/__cycle_obj.hpp

@@ -1,6 +1,6 @@
-#ifndef AFUN___CYCLE_OBJ_H
-#define AFUN___CYCLE_OBJ_H
+#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_H
+#endif //AFUN___CYCLE_OBJ_HPP

src/runtime/__runtime.h → src/runtime/__runtime.hpp

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

src/runtime/aFunlang.c → src/runtime/aFunlang.cpp

@@ -1,7 +1,7 @@
-#include "aFunCore.h"
-#include "__aFunlang.h"
-#include "__env.h"
-#include "__cycle_obj.h"
+#include "aFunCore.hpp"
+#include "__aFunlang.hpp"
+#include "__env.hpp"
+#include "__cycle_obj.hpp"
 
 #ifdef aFunWIN32_NO_CYGWIN
 #include <io.h>
@@ -20,7 +20,9 @@ struct guardian_GC_data{
 };
 
 /* 内置守护器 */
-static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char err[], af_Environment *env);
+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);
 
@@ -28,19 +30,19 @@ bool aFunInit(aFunInitInfo *info) {
     if (aFunInit_mark)
         return false;
 
-    if (info == NULL) {
+    if (info == nullptr) {
         static aFunInitInfo info_default = {
                 .base_dir=".",
-                .buf=NULL,
                 .log_asyn=true,
+                .buf=nullptr,
                 .level=log_info
         };
         info = &info_default;
     }
 
     aFunCoreInitInfo core_info = {.base_dir=info->base_dir,
-                                  .buf=info->buf,
                                   .log_asyn=info->log_asyn,
+                                  .buf=info->buf,
                                   .level=info->level};
 
     aFunInit_mark = aFunCoreInit(&core_info);
@@ -49,7 +51,7 @@ bool aFunInit(aFunInitInfo *info) {
     return aFunInit_mark;
 }
 
-bool aFunDestruct(void) {
+bool aFunDestruct() {
     return aFunCoreDestruct();
 }
 
@@ -72,13 +74,15 @@ void undefRunEnv(aFunRunInfo *run_env) {
 }
 
 
-static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char err[], af_Environment *env) {
+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 != NULL)
+    if (p_cfg != nullptr)
         cfg = *p_cfg;
 
     if (cfg == 0) {  // 诱发错误
@@ -100,11 +104,11 @@ static bool checkSignal(int signum, char *sig, char *sigcfg, char *sigerr, char
 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 NULL;
+        return nullptr;
     data->last_time = now;
 
     af_GuardianList *gl = gc_RunGC(env);
-    if (gl != NULL)
+    if (gl != nullptr)
         writeDebugLog(aFunCoreLogger, "GC run destruct function");
     return gl;
 }
@@ -120,7 +124,7 @@ static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, a
 
     if (*error_msg != NUL) {
         // error_msg 有内容写入, 需要处理
-        if (env->activity->msg_down != NULL) {
+        if (env->activity->msg_down != nullptr) {
             af_Message *msg;
             if (EQ_STR("NORMAL", env->activity->msg_down->type)) {
                 msg = getFirstMessage(env);
@@ -135,16 +139,16 @@ static af_GuardianList *guardian_Signal(char *type, bool is_guard, void *data, a
 
         pushMessageDown(makeERRORMessage(SIGNAL_EXCEPTION, error_msg, env), env);
     }
-    return NULL;
+    return nullptr;
 }
 
 
 af_Environment *creatAFunEnvironment(int argc, char **argv){
     if (!aFunInit_mark)
-        return NULL;
+        return nullptr;
 
     af_Environment *env = makeEnvironment(grt_always);
-    af_Code *code = NULL;
+    af_Code *code = nullptr;
 
     for(int i = 0; i < argc; i++)
         writeTrackLog(aFunCoreLogger, "[aFunlang] Env-arg %d. %s", i, argv[i]);
@@ -156,14 +160,14 @@ af_Environment *creatAFunEnvironment(int argc, char **argv){
         setEnvVarData(tmp, argv[i], env);
     }
 
-    runtimeTool("base", &code, NULL, env->protect, env);
+    runtimeTool("base", &code, nullptr, env->protect, env);
 
-    if (code != NULL) {
+    if (code != nullptr) {
         bool res = iterCode(code, 0, env);
         freeAllCode(code);
         if (!res) {
             freeEnvironment(env);
-            return NULL;
+            return nullptr;
         }
     }
 
@@ -173,23 +177,23 @@ af_Environment *creatAFunEnvironment(int argc, char **argv){
 
     enableEnvironment(env);
     if (!env->is_derive) {  // 派生 gc 线程
-        setVarSpaceProtect(NULL, env->protect, true);
+        setVarSpaceProtect(nullptr, env->protect, true);
 
-        af_Environment *gc_env = startRunThread(env, NULL, NULL, true, true, false, true, false);
+        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, NULL, NULL, gc_env);
+        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, NULL, NULL, gc_env);
+                    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", NULL);
+        af_Code *bt2 = makeBlockCode(curly, bt1, NUL, 1, "gc.aun.sys", nullptr);
         startRunThread_(gc_env, bt2, true);
         env->gc_env = gc_env;
     }
@@ -203,16 +207,16 @@ bool destructAFunEnvironment(af_Environment *env) {
 }
 
 static int runCode_(af_Parser *parser, int mode, FilePath save_path, af_Environment *env){
-    if (parser == NULL)
+    if (parser == nullptr)
         return -1;
 
     af_Code *bt_code = parserCode(parser);
     freeParser(parser);
-    if (bt_code == NULL)
+    if (bt_code == nullptr)
         return -2;
 
     /* 写入文件 */
-    if (save_path != NULL) {
+    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]);
@@ -232,15 +236,15 @@ static int runCode_(af_Parser *parser, int mode, FilePath save_path, af_Environm
  * 函数名: runCodeFromString
  * 目标: 运行字符串中的程序 (源码形式)
  */
-int runCodeFromString(char *code, char *string_name, int mode, af_Environment *env){
-    if (env == NULL || code == NULL || !aFunInit_mark)
+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 == NULL)
+    if (string_name == nullptr)
         string_name = "string-code.aun";
 
     af_Parser *parser = makeParserByString(string_name, code, false);
-    return runCode_(parser, mode, NULL, env);
+    return runCode_(parser, mode, nullptr, env);
 }
 
 /*
@@ -248,13 +252,13 @@ int runCodeFromString(char *code, char *string_name, int mode, af_Environment *e
  * 目标: 运行文件中的程序 (源码形式)
  */
 int runCodeFromFileSource(FilePath file, bool save_afb, FilePath save_path, int mode, af_Environment *env){
-    if (env == NULL || file == NULL || !aFunInit_mark)
+    if (env == nullptr || file == nullptr || !aFunInit_mark)
         return -1;
 
     char *sufix = getFileSurfix(file);
-    if (sufix == NULL || !EQ_STR(".aun", sufix)) {
-        writeErrorLog(aFunCoreLogger, "Source is not .aun file: %s", (sufix == NULL ? "" : sufix));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_source_not_aub_e, "Source is not .aun file"), (sufix == NULL ? "" : sufix));
+    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;
     }
 
@@ -265,7 +269,7 @@ int runCodeFromFileSource(FilePath file, bool save_afb, FilePath save_path, int
         save_path = strJoin(path, ".aub", true, false);
         free_save_path = true;
     } else if (!save_afb)
-        save_path = NULL;
+        save_path = nullptr;
 
     af_Parser *parser = makeParserByFile(file);
     int exit_code = runCode_(parser, mode, save_path, env);
@@ -278,15 +282,15 @@ int runCodeFromFileSource(FilePath file, bool save_afb, FilePath save_path, int
  * 函数名: runCodeFromStdin
  * 目标: 运行stdin的程序 (源码形式)
  */
-int runCodeFromStdin(char *name, af_Environment *env){
-    if (env == NULL || CLEAR_STDIN() || !aFunInit_mark || !isatty(fileno(stdin)))  // ferror在feof前执行
+int runCodeFromStdin(const char *name, af_Environment *env){
+    if (env == nullptr || CLEAR_STDIN() || !aFunInit_mark || !isatty(fileno(stdin)))  // ferror在feof前执行
         return -1;
 
-    if (name == NULL)
+    if (name == nullptr)
         name = "sys-stdin.aun";
 
     af_Parser *parser = makeParserByStdin(name);
-    return runCode_(parser, 0, NULL, env);
+    return runCode_(parser, 0, nullptr, env);
 }
 
 /*
@@ -308,17 +312,17 @@ int runCodeFromMemory(af_Code *code, int mode, af_Environment *env){
  * 目标: 运行文件中的程序 (字节码形式)
  */
 int runCodeFromFileByte(FilePath file, int mode, af_Environment *env){
-    if (env == NULL || file == NULL || !aFunInit_mark)
+    if (env == nullptr || file == nullptr || !aFunInit_mark)
         return -1;
 
     char *sufix = getFileSurfix(file);
-    if (sufix == NULL || !EQ_STR(".aub", sufix)) {
-        writeErrorLog(aFunCoreLogger, "Bytecode not .aub file: %s", (sufix == NULL ? "" : sufix));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(run_bt_not_aub_e, "Bytecode not .aub file"), (sufix == NULL ? "" : sufix));
+    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 = NULL;
+    af_Code *code = nullptr;
     int res = readByteCode(&code, file);
     if(res != 1) {
         writeErrorLog(aFunCoreLogger, "Load %s bytecode file error: %s", file, readByteCodeError[res]);
@@ -336,11 +340,11 @@ int runCodeFromFileByte(FilePath file, int mode, af_Environment *env){
  * 目标: 运行文件中的程序 (字节码/源码形式)
  */
 int runCodeFromFile(FilePath file, bool save_afb, int mode, af_Environment *env){
-    if (env == NULL || file == NULL || !aFunInit_mark)
+    if (env == nullptr || file == nullptr || !aFunInit_mark)
         return -1;
 
     char *sufix = getFileSurfix(file);
-    if (sufix != NULL && !EQ_STR(".aun", sufix) && !EQ_STR(".aub", sufix)) {  // 不是源文件, 字节码文件或无后缀文件
+    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;
@@ -381,27 +385,27 @@ RUN_SOURCE_CODE:
  * 目标: 生成字节码文件
  */
 int buildFile(FilePath out, FilePath in){
-    if (out == NULL || in == NULL || !aFunInit_mark)
+    if (out == nullptr || in == nullptr || !aFunInit_mark)
         return -1;
 
     char *suffix_in = getFileSurfix(in);
     char *suffix_out = getFileSurfix(out);
-    if (suffix_in == NULL || !EQ_STR(".aun", suffix_in)) {  // 不是源文件
-        writeErrorLog(aFunCoreLogger, "Input not .aun %s", (suffix_in == NULL ? "" : suffix_in));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(build_in_aun_e, "Input file is not .aun file"), (suffix_in == NULL ? "" : suffix_in));
+    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 == NULL || !EQ_STR(".aub", suffix_out)) {  // 不是字节码文件
-        writeErrorLog(aFunCoreLogger, "Output not .aub %s", (suffix_out == NULL ? "" : suffix_out));
-        printf_stderr(0, "%s: %s\n", HT_aFunGetText(build_out_aub_e, "Output file is not .aub file"), (suffix_out == NULL ? "" : suffix_out));
+    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 == NULL)
+    if (code == nullptr)
         return -2;
 
     int res = writeByteCode(code, out);

src/runtime/base/__base.h → src/runtime/base/__base.hpp

@@ -1,13 +1,13 @@
-#ifndef AFUN___BASE_H
-#define AFUN___BASE_H
-#include "__runtime.h"
-#include "__env.h"
-#include "__var.h"
+#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=NULL}
+        {.pattern=nullptr}
 };
 
 #define string_id "string"
@@ -19,4 +19,4 @@ struct ObjectString{
 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_H
+#endif //AFUN___BASE_HPP

src/runtime/base/base.c → src/runtime/base/base.cpp

@@ -1,4 +1,4 @@
-#include "__base.h"
+#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);

src/runtime/base/quit.c → src/runtime/base/quit.cpp

@@ -1,4 +1,4 @@
-#include "__base.h"
+#include "__base.hpp"
 
 #define func_id "quit-func"
 
@@ -18,17 +18,17 @@ static void funcInit(char *id, af_Object *obj, QuitFunc *data, af_Environment *e
 }
 
 static bool funcArgCodeList(char *id, af_Object *obj, af_ArgCodeList **acl, af_Code *code, void **mark, af_Environment *env) {
-    *acl = NULL;
+    *acl = nullptr;
     return true;
 }
 
 static bool funcArgList(char *id, af_Object *obj, af_ArgList **al, af_ArgCodeList *acl, void *mark, af_Environment *env) {
-    *al = NULL;
+    *al = nullptr;
     return true;
 }
 
 static bool funcVarList(char *id, af_Object *obj, af_VarList **vsl, void *mark, af_Environment *env) {
-    QuitFunc *sf = getObjectData(obj);
+    auto sf = (QuitFunc *)getObjectData(obj);
     *vsl = sf->func_var_list;
     return true;
 }
@@ -36,13 +36,13 @@ static bool funcVarList(char *id, af_Object *obj, af_VarList **vsl, void *mark,
 static af_FuncBody *funcBody(af_CallFuncInfo *cfi, af_Environment *env) {
     setCoreExit(0, env);
     pushMessageDown(makeNORMALMessage(getGlobal(env), env), env);
-    return NULL;
+    return nullptr;
 }
 
 static bool funcGetInfo(char *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, NULL, *fi);
+    makeCFuncBodyToFuncInfo(func, nullptr, *fi);
     FREE_SYMBOL(func);
     return true;
 }
@@ -54,20 +54,20 @@ static void funcDestruct(char *id, af_Object *obj, QuitFunc *data, af_Environmen
 
 void makeQuitFunc(af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
     static APIFuncList api_list[] = {
-            {.name="obj_getDataSize", .func=funcGetSize, .dlc=NULL},
-            {.name="obj_initData", .func=funcInit, .dlc=NULL},
-            {.name="obj_destructData", .func=funcDestruct, .dlc=NULL},
-            {.name="obj_funcGetArgCodeList", .func=funcArgCodeList, .dlc=NULL},
-            {.name="obj_funcGetVarList", .func=funcVarList, .dlc=NULL},
-            {.name="obj_funcGetArgList", .func=funcArgList, .dlc=NULL},
-            {.name="obj_funcGetInfo", .func=funcGetInfo, .dlc=NULL},
-            {.name=NULL}
+            {.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=NULL}
+            {.id=nullptr}
     };
 
     makeObjectFromList(obj_def, visitor, vs, env);

src/runtime/base/str_obj.c → src/runtime/base/str_obj.cpp

@@ -1,4 +1,4 @@
-#include "__base.h"
+#include "__base.hpp"
 
 #define string_func_id "string-maker"
 typedef struct ObjectStrFunc ObjectStrFunc;
@@ -14,7 +14,7 @@ static size_t strGetSize(char *id, af_Object *obj) {
 
 static void strInit(char *id, af_Object *obj, ObjectString *data, af_Environment *env) {
     if (EQ_STR(id, string_id))
-        data->str = NULL;
+        data->str = nullptr;
 }
 
 static void strDestruct(char *id, af_Object *obj, ObjectString *data, af_Environment *env) {
@@ -24,7 +24,7 @@ static void strDestruct(char *id, af_Object *obj, ObjectString *data, af_Environ
 }
 
 static void strLiteral(char *id, af_Object *obj, ObjectString *data, char *str, af_Environment *env) {
-    if (!EQ_STR(id, string_id) || data->str != NULL)
+    if (!EQ_STR(id, string_id) || data->str != nullptr)
         return;
     writeTrackLog(aFunCoreLogger, "strLiteral str = %s, %d", str, strlen(str));
     data->str = NEW_STR(STR_LEN(str) - 2);  // 取出两个引号
@@ -37,11 +37,11 @@ static size_t strFuncGetSize(char *id, af_Object *obj) {
 
 static void strFuncInit(char *id, af_Object *obj, ObjectStrFunc *data, af_Environment *env) {
     static const APIFuncList api_list[] = {
-            {.name="obj_getDataSize", .func=strGetSize, .dlc=NULL},
-            {.name="obj_initData", .func=strInit, .dlc=NULL},
-            {.name="obj_destructData", .func=strDestruct, .dlc=NULL},
-            {.name="obj_literalSetting", .func=strLiteral, .dlc=NULL},
-            {.name=NULL}
+            {.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 (!EQ_STR(id, string_func_id))
@@ -53,39 +53,39 @@ static void strFuncInit(char *id, af_Object *obj, ObjectStrFunc *data, af_Enviro
 }
 
 static bool strFuncArgCodeList(char *id, af_Object *obj, af_ArgCodeList **acl, af_Code *code, void **mark, af_Environment *env) {
-    *acl = NULL;
+    *acl = nullptr;
     return true;
 }
 
 static bool strFuncArgList(char *id, af_Object *obj, af_ArgList **al, af_ArgCodeList *acl, void *mark, af_Environment *env) {
-    *al = NULL;
+    *al = nullptr;
     return true;
 }
 
 static bool strFuncVarList(char *id, af_Object *obj, af_VarList **vsl, void *mark, af_Environment *env) {
-    ObjectStrFunc *sf = getObjectData(obj);
+    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;
-    ObjectStrFunc *osf = getObjectData(obj);
-    af_Object *str = makeObject((char *) string_id, false, osf->api, false, NULL, true, makeInherit(obj), env);
+    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 NULL;
+    return nullptr;
 }
 
 static bool strFuncGetInfo(char *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, NULL, *fi);
+    makeCFuncBodyToFuncInfo(func, nullptr, *fi);
     FREE_SYMBOL(func);
     return true;
 }
 
 static af_GcList *strFuncGetGc(char *id, af_Object *obj, ObjectStrFunc *data) {
-    af_GcList *gl = pushGcList(glt_vsl, data->func_var_list, NULL);
+    af_GcList *gl = pushGcList(glt_vsl, data->func_var_list, nullptr);
     gl = pushGcList(glt_vs, data->share_vs, gl);
     return gl;
 }
@@ -99,21 +99,21 @@ static void strFuncDestruct(char *id, af_Object *obj, ObjectStrFunc *data, af_En
 
 void makeStrFunc(af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
     static APIFuncList api_list[] = {
-            {.name="obj_getDataSize", .func=strFuncGetSize, .dlc=NULL},
-            {.name="obj_initData", .func=strFuncInit, .dlc=NULL},
-            {.name="obj_destructData", .func=strFuncDestruct, .dlc=NULL},
-            {.name="obj_funcGetArgCodeList", .func=strFuncArgCodeList, .dlc=NULL},
-            {.name="obj_funcGetVarList", .func=strFuncVarList, .dlc=NULL},
-            {.name="obj_funcGetArgList", .func=strFuncArgList, .dlc=NULL},
-            {.name="obj_funcGetInfo", .func=strFuncGetInfo, .dlc=NULL},
-            {.name="obj_getGcList", .func=strFuncGetGc, .dlc=NULL},
-            {.name=NULL}
+            {.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=NULL}
+            {.id=nullptr}
     };
 
     makeObjectFromList(obj_def, visitor, vs, env);

src/runtime/cycle_obj.c → src/runtime/cycle_obj.cpp

@@ -1,12 +1,12 @@
-#include "aFunlang.h"
-#include "__cycle_obj.h"
+#include "aFunlang.hpp"
+#include "__cycle_obj.hpp"
 
 size_t getSizec_Cycle(char *id, af_Object *obj) {
     return sizeof(af_VarList *);
 }
 
 void initDatac_Cycle(char *id, af_Object *obj, af_VarList **data, af_Environment *env) {
-    *data = pushProtectVarList(NULL, env);
+    *data = pushProtectVarList(nullptr, env);
 }
 
 void freeDatac_Cycle(char *id, af_Object *obj, af_VarList **data, af_Environment *env) {
@@ -20,10 +20,10 @@ struct CycleMark {
 };
 
 af_FuncBody *func_Cycle(af_CallFuncInfo *cfi, af_Environment *env) {  // 测试用函数
-    CycleMark *mark = cfi->mark;
+    auto mark = (CycleMark *)cfi->mark;
     cfi->body_next = mark->body;
     pushMessageDown(makeNORMALMessage(getGlobal(env), env), env);
-    return NULL;
+    return nullptr;
 }
 
 bool getInfoc_Cycle(char *id, af_Object *obj, af_FuncInfo **fi, af_Code *code, CycleMark *mark, af_Environment *env) {
@@ -31,15 +31,15 @@ bool getInfoc_Cycle(char *id, af_Object *obj, af_FuncInfo **fi, af_Code *code, C
     *fi = mark->fi;
 
     DLC_SYMBOL(callFuncBody) func = MAKE_SYMBOL(func_Cycle, callFuncBody);
-    mark->body = makeCFuncBodyToFuncInfo(func, NULL, mark->fi);  // 压入两个相同的 body
+    mark->body = makeCFuncBodyToFuncInfo(func, nullptr, mark->fi);  // 压入两个相同的 body
     FREE_SYMBOL(func);
 
     return true;
 }
 
 bool getAclc_Cycle(char *id, af_Object *obj, af_ArgCodeList **acl, af_Code *code, CycleMark **mark, af_Environment *env) {
-    *acl = NULL;
-    *mark = calloc(1, sizeof(CycleMark));
+    *acl = nullptr;
+    *mark = calloc(1, CycleMark);
     return true;
 }
 
@@ -49,12 +49,12 @@ bool getVslc_Cycle(char *id, af_Object *obj, af_VarList **vsl, CycleMark *mark,
 }
 
 af_GcList *getGcListc_Cycle(char *id, af_Object *obj, void *data) {
-    af_GcList *gl = pushGcList(glt_vsl, *(af_VarList **)data, NULL);
+    af_GcList *gl = pushGcList(glt_vsl, *(af_VarList **)data, nullptr);
     return gl;
 }
 
 bool getAlc_Cycle(char *id, af_Object *obj, af_ArgList **al, af_ArgCodeList *acl, CycleMark *mark, af_Environment *env) {
-    *al = NULL;
+    *al = nullptr;
     return true;
 }
 
@@ -74,23 +74,23 @@ af_Object *makeCycleObject(af_Environment *env) {
     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 NULL;
+        return nullptr;
     if (addAPI(init_data, "obj_initData", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(free_data, "obj_destructData", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(get_alc, "obj_funcGetArgCodeList", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(get_vsl, "obj_funcGetVarList", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(get_al, "obj_funcGetArgList", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(get_info, "obj_funcGetInfo", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(free_mark, "obj_funcFreeMask", api) != 1)
-        return NULL;
+        return nullptr;
     if (addAPI(get_gl, "obj_getGcList", api) != 1)
-        return NULL;
+        return nullptr;
 
     FREE_SYMBOL(get_alc);
     FREE_SYMBOL(get_vsl);
@@ -102,5 +102,5 @@ af_Object *makeCycleObject(af_Environment *env) {
     FREE_SYMBOL(init_data);
     FREE_SYMBOL(free_data);
 
-    return makeObject("func", true, api, true, NULL, true, NULL, env);
+    return makeObject("func", true, api, true, nullptr, true, nullptr, env);
 }

src/runtime/runtime.c → src/runtime/runtime.cpp

@@ -1,11 +1,11 @@
-#include "__runtime.h"
-#include "__global_obj.h"
-#include "runtime_tool.h"
+#include "__runtime.hpp"
+#include "__global_obj.hpp"
+#include "runtime_tool.hpp"
 
 /* 数组为只读的内容 */
 static const ToolFunc global_tool_list[] = {
         {.name="base", .func=aFunTool_base},
-        {.name=NULL, .func=NULL},
+        {.name=nullptr, .func=nullptr},
 };
 
 /**
@@ -15,11 +15,11 @@ static const ToolFunc global_tool_list[] = {
  * 返回 (1)  库不存在
  * 必须保证 vs 有被 gc 引用
  */
-int runtimeTool(char *name, af_Code **code, af_Object *visitor, af_VarSpace *vs, af_Environment *env) {
-    if (name == NULL || code == NULL || env == NULL || vs == NULL)
+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 = NULL;
-    for (const ToolFunc *tf = global_tool_list; global_tool_list->name != NULL; tf++) {
+    *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
@@ -34,8 +34,8 @@ int runtimeTool(char *name, af_Code **code, af_Object *visitor, af_VarSpace *vs,
  * 函数名: runtimeToolImport
  * 目标: 生成vs, 调用指定内置包(tool)
  */
-int runtimeToolImport(char *name, af_Object **obj, af_Code **code, af_Environment *env) {
-    if (name == NULL || code == NULL || env == NULL || obj == NULL)
+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);
@@ -48,13 +48,13 @@ int runtimeToolImport(char *name, af_Object **obj, af_Code **code, af_Environmen
 af_ObjectAPI *makeAPIFromList(const APIFuncList api_list[]) {
     af_ObjectAPI *api = makeObjectAPI();
 
-    for (const APIFuncList *af = api_list; af->name != NULL; af++) {
-        if (af->func != NULL) {
+    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_ == NULL)
+        } else if (af->func_ == nullptr)
             continue;  // 遇到错误
 
         addAPI(af->func_, af->name, api);
@@ -70,18 +70,18 @@ af_ObjectAPI *makeAPIFromList(const APIFuncList api_list[]) {
  * 必须保证 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 != NULL; od++) {
+    for (const ObjectDefineList *od = obj_def; od->id != nullptr; od++) {
         af_ObjectAPI *api = od->api;
-        if (api == NULL)
+        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 != NULL && od->var_name != NULL) {
+        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 != NULL)
+        if (od->save != nullptr)
             *(od->save) = obj;
         else
             gc_delObjectReference(obj, env);
@@ -93,7 +93,7 @@ void makeObjectFromList(const ObjectDefineList obj_def[], af_Object *visitor, af
  * 目标: 根据LiteralFuncList压入新的字面量处理器
  */
 void makeLiteralRegexFromList(const LiteralFuncList literal_list[], af_Environment *env) {
-    for (const LiteralFuncList *lt = literal_list; lt->pattern != NULL; lt++)
+    for (const LiteralFuncList *lt = literal_list; lt->pattern != nullptr; lt++)
         pushLiteralRegex(lt->pattern, lt->func, lt->in_protect, env);
 }
 
@@ -102,13 +102,13 @@ void makeLiteralRegexFromList(const LiteralFuncList literal_list[], af_Environme
  * 目标: 根据TopMsgFuncList压入新的字面量处理器
  */
 void makeTopMsgProcessFromList(const TopMsgFuncList top_msg_list[], af_Environment *env) {
-    for (const TopMsgFuncList *tml = top_msg_list; tml->type != NULL; tml++) {
-        if (tml->func != NULL) {
+    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_ == NULL)
+        } else if (tml->func_ == nullptr)
             continue;  // 遇到错误
 
         addTopMsgProcess(tml->type, tml->func_, env);
@@ -123,9 +123,9 @@ void makeTopMsgProcessFromList(const TopMsgFuncList top_msg_list[], af_Environme
  * 注意: pushInherit是反向压入, 因此InheritDefine得正向读取, 最后Inherit反向压入
  */
 static af_Inherit *makeInheritFromListReverse(const InheritDefineList inherit_list[]) {
-    af_Inherit *inherit = NULL;
+    af_Inherit *inherit = nullptr;
     af_Inherit **pinherit = &inherit;
-    for (const InheritDefineList *ind = inherit_list; ind->obj != NULL; ind++) {
+    for (const InheritDefineList *ind = inherit_list; ind->obj != nullptr; ind++) {
         af_Inherit *ih = makeInherit(ind->obj);
         pinherit = pushInherit(pinherit, ih);
     }
@@ -139,16 +139,16 @@ static af_Inherit *makeInheritFromListReverse(const InheritDefineList inherit_li
  * 注意: pushInherit是反向压入, 因此InheritDefine也得反向读取, 最后Inherit正向压入
  */
 static af_Inherit *makeInheritFromListForward(const InheritDefineList inherit_list[]) {
-    af_Inherit *inherit = NULL;
+    af_Inherit *inherit = nullptr;
     af_Inherit **pinherit = &inherit;
     const InheritDefineList *ind = inherit_list;
 
     /* 找到最后一个元素 */
-    while (ind->obj != NULL)
+    while (ind->obj != nullptr)
         ind++;
     ind--;  // 最后一个元素的前一个元素为最后一个有效元素
 
-    for (NULL; ind != inherit_list; ind++) {
+    for(NULL; ind != inherit_list; ind++) {
         af_Inherit *ih = makeInherit(ind->obj);
         pinherit = pushInherit(pinherit, ih);
     }
@@ -172,30 +172,30 @@ af_Inherit *makeInheritFromList(const InheritDefineList inherit_list[], bool is_
  * 目标: 根据GuardianFuncList压入新的字面量处理器
  */
 void makeGuardianFromList(const GuardianFuncList gd_list[], af_Environment *env) {
-    for (const GuardianFuncList *gdl = gd_list; gdl->type != NULL; gdl++) {
+    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 == NULL) {
-            if (gdl->func == NULL)
+        if (func == nullptr) {
+            if (gdl->func == nullptr)
                 continue;  // 遇到错误
             func = MAKE_SYMBOL_FROM_HANDLE(gdl->func, gdl->dlc, GuardianFunc);
             free_func_ = true;
         }
 
-        if (destruct == NULL) {
-            if (gdl->destruct == NULL)
+        if (destruct == nullptr) {
+            if (gdl->destruct == nullptr)
                 continue;  // 遇到错误
             destruct = MAKE_SYMBOL_FROM_HANDLE(gdl->destruct, gdl->dlc, GuardianDestruct);
             free_destruct_ = true;
         }
 
-        void *tmp = NULL;
+        void *tmp = nullptr;
         void **pdata = gdl->data;
-        if (pdata == NULL)
+        if (pdata == nullptr)
             pdata = &tmp;
 
         if (addGuardian(gdl->type, gdl->always, gdl->derive, gdl->size, func, destruct, pdata, env))

src/runtime/runtime_tool.h → src/runtime/runtime_tool.hpp

@@ -1,6 +1,6 @@
-#ifndef AFUN_RUNTIME_TOOL_H
-#define AFUN_RUNTIME_TOOL_H
+#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_H
+#endif //AFUN_RUNTIME_TOOL_HPP