feat: 变量名使用宽字符支持

变量名等直接保存为wchar_t的形式

link #8

VirtulMathCore/include/__macro.h

@@ -23,9 +23,9 @@
 #define REGISTERED_FUNCTIONSIG struct LinkValue *belong, INTER_FUNCTIONSIG_CORE
 #define CALL_REGISTERED_FUNCTION(belong, var_list) belong, CALL_INTER_FUNCTIONSIG_CORE(var_list)
 
-#define MD5_SIZE 16
+#define MD5_SIZE (16)
 #define MD5_STR_LEN (MD5_SIZE * 2)
-#define MD5_STRING MD5_STR_LEN + 1
+#define MD5_STRING (MD5_STR_LEN + 1)
 
 typedef long long vnum;
 typedef unsigned long long vhashn;

VirtulMathCore/include/inter.h

@@ -55,38 +55,39 @@ struct Inter{
         struct LinkValue *import_exc;
         struct LinkValue *include_exp;
 
-        char *var_str_prefix;
-        char *var_num_prefix;
-        char *var_bool_prefix;
-        char *var_none;
-        char *var_pass;
-        char *var_class_prefix;
-        char *var_object_prefix;
-        char *object_init;
-        char *object_new;
-        char *object_call;
-        char *object_enter;
-        char *object_exit;
-        char *object_add;
-        char *object_sub;
-        char *object_mul;
-        char *object_div;
-        char *object_del;
-        char *object_down;
-        char *object_slice;
-        char *object_iter;
-        char *object_next;
-        char *object_repo;
-        char *object_bool;
-        char *object_name;
-        char *object_self;
-        char *object_father;
-        char *object_message;
-        char *object_str;
-        char *object_down_assignment;
-        char *object_slice_assignment;
-        char *object_down_del;
-        char *object_slice_del;
+        wchar_t *var_str_prefix;
+        wchar_t *var_num_prefix;
+        wchar_t *var_bool_prefix;
+        wchar_t *var_none;
+        wchar_t *var_pass;
+        wchar_t *var_class_prefix;
+        wchar_t *var_object_prefix;
+        wchar_t *object_init;
+        wchar_t *object_new;
+        wchar_t *object_call;
+        wchar_t *object_enter;
+        wchar_t *object_exit;
+        wchar_t *object_add;
+        wchar_t *object_sub;
+        wchar_t *object_mul;
+        wchar_t *object_div;
+        wchar_t *object_del;
+        wchar_t *object_down;
+        wchar_t *object_slice;
+        wchar_t *object_iter;
+        wchar_t *object_next;
+        wchar_t *object_repo;
+        wchar_t *object_bool;
+        wchar_t *object_name;
+        wchar_t *object_self;
+        wchar_t *object_father;
+        wchar_t *object_message;
+        wchar_t *object_str;
+        wchar_t *object_down_assignment;
+        wchar_t *object_slice_assignment;
+        wchar_t *object_down_del;
+        wchar_t *object_slice_del;
+
         int default_pt_type;
     } data;
 };

VirtulMathCore/include/ofunc.h

@@ -22,7 +22,7 @@ struct Inherit;
 struct Inter;
 
 struct NameFunc{
-    char *name;
+    wchar_t *name;
     OfficialFunction of;
     enum FunctionPtType type;
 };

VirtulMathCore/include/parameter.h

@@ -31,7 +31,7 @@ struct Argument{
     struct ArgumentData{
         struct LinkValue *value;
         struct Statement *name;  // 仅在name-value模式生效
-        char *name_;
+        wchar_t *name_;
         struct LinkValue *name_value;
     } data;
     struct Argument *next;
@@ -40,7 +40,7 @@ struct Argument{
 struct ArgumentParser{
     struct LinkValue *value;
     struct Argument *arg;
-    char *name;
+    wchar_t *name;
     enum ArgumentParserType{
         only_value,
         name_value,
@@ -58,11 +58,11 @@ typedef struct ArgumentParser ArgumentParser;
 Argument *makeArgument(void);
 Argument *makeValueArgument(LinkValue *value);
 Argument *makeStatementNameArgument(LinkValue *value, struct Statement *name);
-Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, char *name);
+Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, wchar_t *name);
 Argument *connectArgument(Argument *new, Argument *base);
 Argument *connectValueArgument(LinkValue *value, Argument *base);
 Argument *connectStatementNameArgument(LinkValue *value, struct Statement *name, Argument *base);
-Argument *connectCharNameArgument(LinkValue *value, LinkValue *name_value, char *name, Argument *base);
+Argument *connectCharNameArgument(LinkValue *value, LinkValue *name_value, wchar_t *name, Argument *base);
 void freeArgument(Argument *at, bool free_st);
 
 Parameter *makeParameter(void);

VirtulMathCore/include/run.h

@@ -14,7 +14,7 @@ typedef struct Parameter Parameter;
 typedef struct Argument Argument;
 typedef struct DecorationStatement DecorationStatement;
 
-typedef ResultType (*VarInfo)(char **name, int *times, INTER_FUNCTIONSIG);
+typedef ResultType (*VarInfo)(wchar_t **name, int *times, INTER_FUNCTIONSIG);
 
 ResultType globalIterStatement(Result *result, Inter *inter, Statement *st);
 bool operationSafeInterStatement(INTER_FUNCTIONSIG);

VirtulMathCore/include/statement.h

@@ -53,7 +53,7 @@ struct Statement{
             wchar_t *str;
         } base_value;
         struct base_var{
-            char *name;
+            wchar_t *name;
             struct Statement *times;
         } base_var;
         struct{
@@ -270,7 +270,7 @@ Statement *makeOperationStatement(enum OperationType type, Statement *left, Stat
 Statement *makeBaseLinkValueStatement(LinkValue *value, fline line, char *file);
 Statement *makeBaseStrValueStatement(wchar_t *value, enum BaseValueType type, fline line, char *file);
 Statement *makeBaseValueStatement(enum BaseValueType type, fline line, char *file);
-Statement *makeBaseVarStatement(char *name, Statement *times, fline line, char *file);
+Statement *makeBaseVarStatement(wchar_t *name, Statement *times, fline line, char *file);
 Statement *makeBaseSVarStatement(Statement *name, Statement *times);
 Statement *makeBaseDictStatement(Parameter *pt, fline line, char *file);
 Statement *makeTupleStatement(Parameter *pt, enum ListType type, fline line, char *file);

VirtulMathCore/include/var.h

@@ -5,7 +5,7 @@
 
 struct Var{
     GCStatus gc_status;
-    char *name;
+    wchar_t *name;
     struct LinkValue *value;
     struct LinkValue *name_;
     struct Var *next;
@@ -21,7 +21,7 @@ struct HashTable{
 };
 
 struct DefaultVar{
-    char *name;
+    wchar_t *name;
     vnum times;
     struct DefaultVar *next;
 };
@@ -44,7 +44,7 @@ typedef struct DefaultVar DefaultVar;
 typedef struct VarList VarList;
 typedef enum VarOperation VarOperation;
 
-Var *makeVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter);
+Var *makeVar(wchar_t *name, LinkValue *value, LinkValue *name_, Inter *inter);
 void freeVar(Var **var);
 
 HashTable *makeHashTable(Inter *inter);
@@ -53,12 +53,12 @@ void freeHashTable(HashTable **value);
 VarList *makeVarList(Inter *inter, bool make_hash);
 VarList *freeVarList(VarList *vl);
 
-vhashn time33(char *key);
-LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *ht);
-LinkValue *findFromVarList(char *name, vnum times, VarOperation operating, INTER_FUNCTIONSIG_CORE);
-void addVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter, HashTable *ht);
+vhashn time33(wchar_t *key);
+LinkValue *findVar(wchar_t *name, VarOperation operating, Inter *inter, HashTable *ht);
+LinkValue *findFromVarList(wchar_t *name, vnum times, VarOperation operating, INTER_FUNCTIONSIG_CORE);
+void addVar(wchar_t *name, LinkValue *value, LinkValue *name_, Inter *inter, HashTable *ht);
 void updateHashTable(HashTable *update, HashTable *new, Inter *inter);
-void addFromVarList(char *name, LinkValue *name_, vnum times, LinkValue *value, INTER_FUNCTIONSIG_CORE);
+void addFromVarList(wchar_t *name, LinkValue *name_, vnum times, LinkValue *value, INTER_FUNCTIONSIG_CORE);
 
 VarList *pushVarList(VarList *base, Inter *inter);
 VarList *popVarList(VarList *base);
@@ -68,9 +68,9 @@ VarList *connectVarListBack(VarList *base, VarList *back);
 bool comparVarList(VarList *dest, VarList *src);
 VarList *makeObjectVarList(Inherit *value, Inter *inter, VarList *base);
 
-vnum findDefault(DefaultVar *base, char *name);
-DefaultVar *connectDefaultVar(DefaultVar *base, char *name, vnum times);
+vnum findDefault(DefaultVar *base, wchar_t *name);
+DefaultVar *connectDefaultVar(DefaultVar *base, wchar_t *name, vnum times);
 DefaultVar *freeDefaultVar(DefaultVar *dv);
-DefaultVar *makeDefaultVar(char *name, vnum times);
+DefaultVar *makeDefaultVar(wchar_t *name, vnum times);
 
 #endif //VIRTUALMATH_VAR_H

VirtulMathCore/ofunc/include/__ofunc.h

@@ -5,19 +5,19 @@
 #include "__run.h"
 
 void newObjectSettingPresetting(LinkValue *func, LinkValue *name, Inter *inter);
-LinkValue *registeredFunctionCore(OfficialFunction of, char *name, INTER_FUNCTIONSIG_NOT_ST);
+LinkValue *registeredFunctionCore(OfficialFunction of, wchar_t *name, INTER_FUNCTIONSIG_NOT_ST);
 
 bool iterNameFunc(NameFunc *list, INTER_FUNCTIONSIG_NOT_ST);
 bool iterClassFunc(NameFunc *list, INTER_FUNCTIONSIG_NOT_ST);
 
 void iterBaseNameFunc(NameFunc *list, struct LinkValue *father, INTER_FUNCTIONSIG_CORE);
 void iterBaseClassFunc(NameFunc *list, LinkValue *father, INTER_FUNCTIONSIG_CORE);
-Value *makeBaseChildClass(Value *inherit, Inter *inter);
+Value *makeBaseChildClass(Value *inherit, Inter *inter);  // TODO-szh 去除该函数
 Value *makeBaseChildClass2(LinkValue *inherit, Inter *inter);
 LinkValue *makeBaseChildClass3(Value *inherit, Inter *inter);
 LinkValue *makeBaseChildClass4(LinkValue *inherit, Inter *inter);
 
 bool checkIndex(vnum *index, const vnum *size, INTER_FUNCTIONSIG_NOT_ST);
 bool checkSlice(vnum *first, vnum *second, const vnum *stride, vnum size, INTER_FUNCTIONSIG_NOT_ST);
-void addBaseClassVar(char *name, LinkValue *obj, LinkValue *belong, Inter *inter);
+void addBaseClassVar(wchar_t *name, LinkValue *obj, LinkValue *belong, Inter *inter);
 #endif //VIRTUALMATH___OFUNC_H

VirtulMathCore/ofunc/src/__ofunc.c

@@ -1,6 +1,6 @@
 #include "__ofunc.h"
 
-LinkValue *registeredFunctionCore(OfficialFunction of, char *name, INTER_FUNCTIONSIG_NOT_ST) {
+LinkValue *registeredFunctionCore(OfficialFunction of, wchar_t *name, INTER_FUNCTIONSIG_NOT_ST) {
     LinkValue *value = NULL;
     makeCFunctionValue(of, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     value = result->value;
@@ -158,7 +158,7 @@ bool checkSlice(vnum *first, vnum *second, const vnum *stride, vnum size, INTER_
     return true;
 }
 
-void addBaseClassVar(char *name, LinkValue *obj, LinkValue *belong, Inter *inter) {
+void addBaseClassVar(wchar_t *name, LinkValue *obj, LinkValue *belong, Inter *inter) {
     Result result;
     setResultCore(&result);
     addStrVar(name, false, true, obj, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(inter->var_list, &result, belong));

VirtulMathCore/ofunc/src/bool.c

@@ -56,7 +56,7 @@ void registeredBool(REGISTERED_FUNCTIONSIG){
                       {inter->data.object_init, bool_init, object_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("bool", object, belong, inter);
+    addBaseClassVar(L"bool", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/dict.c

@@ -58,12 +58,12 @@ ResultType dict_down(OFFICAL_FUNCTIONSIG){
     }
     {
         LinkValue *element = NULL;
-        char *name = getNameFromValue(ap[1].value->value, inter);
+        wchar_t *name = getNameFromValue(ap[1].value->value, inter);
         element = findVar(name, get_var, inter, ap[0].value->value->data.dict.dict);
         if (element != NULL)
             setResultOperationBase(result, copyLinkValue(element, inter));
         else {
-            char *message = memStrcat("Dict could not find key value: ", name, false, false);
+            char *message = memStrcat("Dict could not find key value: ", wcsToStr(name, true), false, true);
             setResultError(E_KeyException, message, 0, "dict", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             memFree(message);
         }
@@ -88,12 +88,12 @@ ResultType dict_down_del(OFFICAL_FUNCTIONSIG){
     }
     {
         LinkValue *element = NULL;
-        char *name = getNameFromValue(ap[1].value->value, inter);
+        wchar_t *name = getNameFromValue(ap[1].value->value, inter);
         element = findVar(name, del_var, inter, ap[0].value->value->data.dict.dict);
         if (element != NULL)
             setResult(result, inter, belong);
         else{
-            char *message = memStrcat("Cannot delete non-existent keys: ", name, false, false);
+            char *message = memStrcat("Cannot delete non-existent keys: ", wcsToStr(name, false), false, true);
             setResultError(E_KeyException, message, 0, "dict", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             memFree(message);
         }
@@ -107,7 +107,7 @@ ResultType dict_down_assignment(OFFICAL_FUNCTIONSIG){
                            {.type=only_value, .must=1, .long_arg=false},
                            {.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
-    char *name = NULL;
+    wchar_t *name = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
@@ -187,7 +187,7 @@ ResultType dictRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
         setResultError(E_TypeException, INSTANCE_ERROR(dict), 0, "dict", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         return error_return;
     }
-    again = findAttributes(is_repo ? "repo_again" : "str_again", false, ap[0].value, inter);
+    again = findAttributes(is_repo ? L"repo_again" : L"str_again", false, ap[0].value, inter);
     if (again != NULL){
         bool again_ = checkBool(again, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         if (!CHECK_RESULT(result))
@@ -198,7 +198,7 @@ ResultType dictRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
         }
     }
 
-    setBoolAttrible(true, is_repo ? "repo_again" : "str_again", 0, "dict.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    setBoolAttrible(true, is_repo ? L"repo_again" : L"str_again", 0, "dict.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     repo = memWidecpy(L"{");
     for (int i = 0, count = 0; i < MAX_SIZE; i++) {
         for (Var *var = value->data.dict.dict->hashtable[i]; var != NULL; var = var->next, count++) {
@@ -230,7 +230,7 @@ ResultType dictRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
     {
         Result tmp;
         setResultCore(&tmp);
-        setBoolAttrible(false, is_repo ? "repo_again" : "str_again", 0, "dict.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, &tmp, belong));
+        setBoolAttrible(false, is_repo ? L"repo_again" : L"str_again", 0, "dict.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, &tmp, belong));
         if (!RUN_TYPE(tmp.type)) {
             freeResult(result);
             *result = tmp;
@@ -251,7 +251,7 @@ ResultType dict_str(OFFICAL_FUNCTIONSIG){
 
 void registeredDict(REGISTERED_FUNCTIONSIG){
     LinkValue *object = inter->data.dict;
-    NameFunc tmp[] = {{"keys", dict_keys, object_free_},
+    NameFunc tmp[] = {{L"keys", dict_keys, object_free_},
                       {inter->data.object_new, dict_new, class_free_},
                       {inter->data.object_down, dict_down, object_free_},
                       {inter->data.object_iter, dict_iter, object_free_},
@@ -261,7 +261,7 @@ void registeredDict(REGISTERED_FUNCTIONSIG){
                       {inter->data.object_down_del, dict_down_del, object_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("dict", object, belong, inter);
+    addBaseClassVar(L"dict", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/dictiter.c

@@ -2,7 +2,7 @@
 
 ResultType dictiter_init(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
-                           {.type=name_value, .name="dict_", .must=1, .long_arg=false},
+                           {.type=name_value, .name=L"dict_", .must=1, .long_arg=false},
                            {.must=-1}};
     LinkValue *list = NULL;
     LinkValue *list_iter = NULL;
@@ -16,7 +16,7 @@ ResultType dictiter_init(OFFICAL_FUNCTIONSIG){
         return error_return;
     }
     {
-        LinkValue *keys = findAttributes("keys", false, ap[1].value, inter);
+        LinkValue *keys = findAttributes(L"keys", false, ap[1].value, inter);
         Argument *list_arg = NULL;
         LinkValue *listiter_class = NULL;
 
@@ -57,9 +57,9 @@ ResultType dictiter_init(OFFICAL_FUNCTIONSIG){
         gc_freeTmpLink(&listiter_class->gc_status);
     }
     freeResult(result);
-    if (addAttributes("__list", false, list_iter, 0, "dictiter.init", ap[0].value, result, inter, var_list)) {
+    if (addAttributes(L"__list", false, list_iter, 0, "dictiter.init", ap[0].value, result, inter, var_list)) {
         freeResult(result);
-        addAttributes("__dict", false, ap[1].value, 0, "dictiter.init", ap[0].value, result, inter, var_list);
+        addAttributes(L"__dict", false, ap[1].value, 0, "dictiter.init", ap[0].value, result, inter, var_list);
     }
     gc_freeTmpLink(&list_iter->gc_status);
     setResult(result, inter, belong);
@@ -75,7 +75,7 @@ ResultType dictiter_next(OFFICAL_FUNCTIONSIG){
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         return result->type;
-    list_ = findAttributes("__list", false, ap[0].value, inter);
+    list_ = findAttributes(L"__list", false, ap[0].value, inter);
     if (list_ == NULL){
         setResultError(E_TypeException, VALUE_ERROR(__list, listiter), 0, "dictiter", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         return error_return;
@@ -100,7 +100,7 @@ ResultType dictiter_down(OFFICAL_FUNCTIONSIG){
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         return result->type;
-    dict_ = findAttributes("__dict", false, ap[0].value, inter);
+    dict_ = findAttributes(L"__dict", false, ap[0].value, inter);
     if (dict_ == NULL || dict_->value->type != dict){
         setResultError(E_TypeException, VALUE_ERROR(__dict, dict), 0, "dictiter", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         return error_return;
@@ -118,7 +118,7 @@ void registeredDictIter(REGISTERED_FUNCTIONSIG){
                       {inter->data.object_down, dictiter_down, object_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("dictiter", object, belong, inter);
+    addBaseClassVar(L"dictiter", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/error_.c

@@ -9,7 +9,7 @@ static LinkValue *makeException(LinkValue *father, Inter *inter){
 
 ResultType base_exception_init(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
-                           {.type=name_value, .name="message", .must=0, .long_arg=false},
+                           {.type=name_value, .name=L"message", .must=0, .long_arg=false},
                            {.must=-1}};
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -24,33 +24,33 @@ ResultType base_exception_init(OFFICAL_FUNCTIONSIG){
 
 void registeredExcIter(REGISTERED_FUNCTIONSIG){
     struct {
-        char *name;
+        wchar_t *name;
         LinkValue *value;
-    } setList[] = {{"Exception", inter->data.exc},
-                   {"SystemException", inter->data.sys_exc},
-                   {"KeyboardInterrupt", inter->data.keyInterrupt_exc},
-                   {"QuitException", inter->data.quit_exc},
-                   {"TypeException", inter->data.type_exc},
-                   {"ArgumentException", inter->data.arg_exc},
-                   {"PermissionsException", inter->data.per_exc},
-                   {"ResultException", inter->data.result_exc},
-                   {"GotoException", inter->data.goto_exc},
-                   {"NameException", inter->data.name_exc},
-                   {"AssertException", inter->data.assert_exc},
-                   {"IndexException", inter->data.index_exc},
-                   {"KeyException", inter->data.key_exc},
-                   {"StrideException", inter->data.stride_exc},
-                   {"IncludeException", inter->data.include_exp},
-                   {"ImportException", inter->data.import_exc},
-                   {"IterStopException", inter->data.iterstop_exc},
-                   {"SuperException", inter->data.super_exc},
+    } setList[] = {{L"Exception", inter->data.exc},
+                   {L"SystemException", inter->data.sys_exc},
+                   {L"KeyboardInterrupt", inter->data.keyInterrupt_exc},
+                   {L"QuitException", inter->data.quit_exc},
+                   {L"TypeException", inter->data.type_exc},
+                   {L"ArgumentException", inter->data.arg_exc},
+                   {L"PermissionsException", inter->data.per_exc},
+                   {L"ResultException", inter->data.result_exc},
+                   {L"GotoException", inter->data.goto_exc},
+                   {L"NameException", inter->data.name_exc},
+                   {L"AssertException", inter->data.assert_exc},
+                   {L"IndexException", inter->data.index_exc},
+                   {L"KeyException", inter->data.key_exc},
+                   {L"StrideException", inter->data.stride_exc},
+                   {L"IncludeException", inter->data.include_exp},
+                   {L"ImportException", inter->data.import_exc},
+                   {L"IterStopException", inter->data.iterstop_exc},
+                   {L"SuperException", inter->data.super_exc},
                    {NULL, NULL}};
     {
         LinkValue *object = inter->data.base_exc;
-        NameFunc tmp[] = {{"__init__", base_exception_init, object_free_},
+        NameFunc tmp[] = {{L"__init__", base_exception_init, object_free_},
                           {NULL, NULL}};
         gc_addTmpLink(&object->gc_status);
-        addBaseClassVar("BaseException", object, belong, inter);
+        addBaseClassVar(L"BaseException", object, belong, inter);
         iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
         gc_freeTmpLink(&object->gc_status);
     }

VirtulMathCore/ofunc/src/function.c

@@ -72,7 +72,7 @@ void registeredFunction(REGISTERED_FUNCTIONSIG){
     LinkValue *object = inter->data.function;
     NameFunc tmp[] = {{NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("function", object, belong, inter);
+    addBaseClassVar(L"function", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/io.c

@@ -2,7 +2,7 @@
 
 ResultType vm_print(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=true},
-                           {.type=name_value, .name="end", .must=0, .value=NULL},
+                           {.type=name_value, .name=L"end", .must=0, .value=NULL},
                            {.must=-1}};
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -32,7 +32,7 @@ ResultType vm_print(OFFICAL_FUNCTIONSIG){
 
 ResultType vm_input(OFFICAL_FUNCTIONSIG){
     setResultCore(result);
-    ArgumentParser ap[] = {{.type=name_value, .name="message", .must=0, .value=NULL},
+    ArgumentParser ap[] = {{.type=name_value, .name=L"message", .must=0, .value=NULL},
                            {.must=-1}};
     wchar_t *str = memWidecpy(L"\0");
     wint_t ch;
@@ -53,8 +53,8 @@ ResultType vm_input(OFFICAL_FUNCTIONSIG){
 }
 
 void registeredIOFunction(REGISTERED_FUNCTIONSIG){
-    NameFunc tmp[] = {{"print", vm_print, free_},
-                      {"input", vm_input, free_},
+    NameFunc tmp[] = {{L"print", vm_print, free_},
+                      {L"input", vm_input, free_},
                       {NULL, NULL}};
     iterBaseNameFunc(tmp, belong, CALL_INTER_FUNCTIONSIG_CORE(var_list));
 }

VirtulMathCore/ofunc/src/list.c

@@ -368,7 +368,7 @@ ResultType listRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
         return error_return;
     }
     lt = value->data.list.type;
-    again = findAttributes(is_repo ? "repo_again" : "str_again", false, ap[0].value, inter);
+    again = findAttributes(is_repo ? L"repo_again" : L"str_again", false, ap[0].value, inter);
     if (again != NULL){
         bool again_ = checkBool(again, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         if (!CHECK_RESULT(result))
@@ -379,7 +379,7 @@ ResultType listRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
         }
     }
 
-    setBoolAttrible(true, is_repo ? "repo_again" : "str_again", 0, "list.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    setBoolAttrible(true, is_repo ? L"repo_again" : L"str_again", 0, "list.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (lt == value_list)
         repo = memWidecpy(L"[");
     else
@@ -405,7 +405,7 @@ ResultType listRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
     {
         Result tmp;
         setResultCore(&tmp);
-        setBoolAttrible(false, is_repo ? "repo_again" : "str_again", 0, "list.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, &tmp, belong));
+        setBoolAttrible(false, is_repo ? L"repo_again" : L"str_again", 0, "list.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, &tmp, belong));
         if (!RUN_TYPE(tmp.type)) {
             freeResult(result);
             *result = tmp;
@@ -437,7 +437,7 @@ void registeredList(REGISTERED_FUNCTIONSIG){
                           {inter->data.object_slice_del, list_slice_del, object_free_},
                           {NULL, NULL}};
         gc_addTmpLink(&object->gc_status);
-        addBaseClassVar("tuple", object, belong, inter);
+        addBaseClassVar(L"tuple", object, belong, inter);
         iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
         gc_freeTmpLink(&object->gc_status);
     }
@@ -449,7 +449,7 @@ void registeredList(REGISTERED_FUNCTIONSIG){
                           {inter->data.object_slice_assignment, list_slice_assignment, object_free_},
                           {NULL, NULL}};
         gc_addTmpLink(&object->gc_status);
-        addBaseClassVar("list", object, belong, inter);
+        addBaseClassVar(L"list", object, belong, inter);
         iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
         gc_freeTmpLink(&object->gc_status);
     }

VirtulMathCore/ofunc/src/listiter.c

@@ -2,7 +2,7 @@
 
 ResultType listiter_init(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
-                           {.type=name_value, .name="list_", .must=1, .long_arg=false},
+                           {.type=name_value, .name=L"list_", .must=1, .long_arg=false},
                            {.must=-1}};
     LinkValue *index = NULL;
     setResultCore(result);
@@ -20,9 +20,9 @@ ResultType listiter_init(OFFICAL_FUNCTIONSIG){
         return result->type;
 
     freeResult(result);
-    if (addAttributes("__list", false, ap[1].value, 0, "listiter.init", ap[0].value, result, inter, var_list)) {
+    if (addAttributes(L"__list", false, ap[1].value, 0, "listiter.init", ap[0].value, result, inter, var_list)) {
         freeResult(result);
-        addAttributes("__index", false, index, 0, "listiter.init", ap[0].value, result, inter, var_list);
+        addAttributes(L"__index", false, index, 0, "listiter.init", ap[0].value, result, inter, var_list);
     }
 
     setResult(result, inter, belong);
@@ -38,8 +38,8 @@ ResultType listiter_next(OFFICAL_FUNCTIONSIG){
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         return result->type;
-    list_ = findAttributes("__list", false, ap[0].value, inter);
-    index = findAttributes("__index", false, ap[0].value, inter);
+    list_ = findAttributes(L"__list", false, ap[0].value, inter);
+    index = findAttributes(L"__index", false, ap[0].value, inter);
 
     if (list_->value->type != list){
         setResultError(E_TypeException, VALUE_ERROR(listiter.__list, list), 0, "listiter", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -62,7 +62,7 @@ ResultType listiter_next(OFFICAL_FUNCTIONSIG){
         Result tmp_result;
         setResultCore(&tmp_result);
         index->value->data.num.num ++;
-        if (addAttributes("__index", false, index, 0, "listiter.next", ap[0].value, &tmp_result, inter, var_list))
+        if (addAttributes(L"__index", false, index, 0, "listiter.next", ap[0].value, &tmp_result, inter, var_list))
             freeResult(&tmp_result);
         else {
             freeResult(result);
@@ -78,7 +78,7 @@ void registeredListIter(REGISTERED_FUNCTIONSIG){
                       {inter->data.object_next, listiter_next, object_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("listiter", object, belong, inter);
+    addBaseClassVar(L"listiter", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/num.c

@@ -28,7 +28,7 @@ ResultType num_new(OFFICAL_FUNCTIONSIG){
 
 ResultType num_init(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
-                           {.type=name_value, .name="num", .must=0, .long_arg=false},
+                           {.type=name_value, .name=L"num", .must=0, .long_arg=false},
                            {.must=-1}};
     LinkValue *base = NULL;
     setResultCore(result);
@@ -70,7 +70,7 @@ void registeredNum(REGISTERED_FUNCTIONSIG){
                       {inter->data.object_init, num_init, object_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("num", object, belong, inter);
+    addBaseClassVar(L"num", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/object.c

@@ -81,7 +81,7 @@ void registeredObject(REGISTERED_FUNCTIONSIG){
                       {inter->data.object_str,  object_str,  all_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("object", object, belong, inter);
+    addBaseClassVar(L"object", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/pass.c

@@ -29,7 +29,7 @@ void registeredEllipisis(REGISTERED_FUNCTIONSIG){
     NameFunc tmp[] = {{inter->data.object_new, pass_new, class_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("ellipsis", object, belong, inter);
+    addBaseClassVar(L"ellipsis", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/ofunc/src/str.c

@@ -167,7 +167,7 @@ ResultType str_iter(OFFICAL_FUNCTIONSIG){
     if (!CHECK_RESULT(result))
         return result->type;
     freeResult(result);
-    to_list = findAttributes("to_list", false, ap[0].value, inter);
+    to_list = findAttributes(L"to_list", false, ap[0].value, inter);
     if (to_list == NULL){
         setResultError(E_TypeException, "String cannot be converted to list", 0, "str", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         return error_return;
@@ -188,14 +188,14 @@ ResultType str_iter(OFFICAL_FUNCTIONSIG){
 
 void registeredStr(REGISTERED_FUNCTIONSIG){
     LinkValue *object = inter->data.str;
-    NameFunc tmp[] = {{"to_list", str_to_list, object_free_},
+    NameFunc tmp[] = {{L"to_list", str_to_list, object_free_},
                       {inter->data.object_iter, str_iter, object_free_},
                       {inter->data.object_down, str_down, object_free_},
                       {inter->data.object_slice, str_slice, object_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
-    addBaseClassVar("str", object, belong, inter);
+    addBaseClassVar(L"str", object, belong, inter);
     gc_freeTmpLink(&object->gc_status);
 }
 
@@ -216,11 +216,11 @@ LinkValue *callClassOf(LinkValue *obj, Inter *inter, LinkValue *new_func, LinkVa
     return new_name;
 }
 
-LinkValue *makeStrFromOf(LinkValue *str, LinkValue *new, LinkValue *init, char *str_, Inter *inter) {
+LinkValue *makeStrFromOf(LinkValue *str, LinkValue *new, LinkValue *init, wchar_t *str_, Inter *inter) {
     LinkValue *return_;
     return_ = callClassOf(str, inter, new, init);
     memFree(return_->value->data.str.str);
-    return_->value->data.str.str = strToWcs(str_, false);
+    return_->value->data.str.str = memWidecpy(str_);
     return return_;
 }
 
@@ -242,11 +242,11 @@ void strFunctionPresetting(LinkValue *func, LinkValue *func_new, LinkValue *func
 
     LinkValue *new_func = NULL;
     LinkValue *new_name = NULL;
-    char *new_name_ = setStrVarName(inter->data.object_new, false, inter);
+    wchar_t *new_name_ = setStrVarName(inter->data.object_new, false, inter);
 
     LinkValue *init_func = NULL;
     LinkValue *init_name = NULL;
-    char *init_name_ = setStrVarName(inter->data.object_init, false, inter);
+    wchar_t *init_name_ = setStrVarName(inter->data.object_init, false, inter);
 
     new_func = makeFunctionFromValue(func, func_new, func_init, str_new, obj, obj->value->object.var, inter);
     new_func->value->data.function.function_data.pt_type = class_free_;

VirtulMathCore/ofunc/src/sys.c

@@ -4,8 +4,8 @@ ResultType vm_super(OFFICAL_FUNCTIONSIG){
     Value *arg_father = NULL;
     Value *arg_child = NULL;
     LinkValue *next_father = NULL;
-    ArgumentParser ap[] = {{.type=name_value, .name="class_", .must=1, .long_arg=false},
-                           {.type=name_value, .name="obj_", .must=1, .long_arg=false},
+    ArgumentParser ap[] = {{.type=name_value, .name=L"class_", .must=1, .long_arg=false},
+                           {.type=name_value, .name=L"obj_", .must=1, .long_arg=false},
                            {.must=-1}};
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -46,7 +46,7 @@ ResultType vm_super(OFFICAL_FUNCTIONSIG){
 
 ResultType vm_setMethodCore(OFFICAL_FUNCTIONSIG, enum FunctionPtType type){
     LinkValue *function_value = NULL;
-    ArgumentParser ap[] = {{.type=name_value, .name="func", .must=1, .long_arg=false}, {.must=-1}};
+    ArgumentParser ap[] = {{.type=name_value, .name=L"func", .must=1, .long_arg=false}, {.must=-1}};
     setResultCore(result);
     {
         parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -103,16 +103,16 @@ ResultType vm_quit(OFFICAL_FUNCTIONSIG){
 }
 
 void registeredSysFunction(REGISTERED_FUNCTIONSIG){
-    NameFunc tmp[] = {{"super", vm_super, free_},
-                      {"freemethod", vm_freemethod, free_},
-                      {"staticmethod", vm_staticmethod, free_},
-                      {"staticclassmethod", vm_classmethod, free_},
-                      {"staticobjectmethod", vm_objectmethod, free_},
-                      {"classmethod", vm_classfreemethod, free_},
-                      {"objectmethod", vm_objectfreemethod, free_},
-                      {"simplemethod", vm_allfreemethod, free_},
-                      {"simplestaticmethod", vm_allstaticmethod, free_},
-                      {"quit", vm_quit, free_},
+    NameFunc tmp[] = {{L"super", vm_super, free_},
+                      {L"freemethod", vm_freemethod, free_},
+                      {L"staticmethod", vm_staticmethod, free_},
+                      {L"staticclassmethod", vm_classmethod, free_},
+                      {L"staticobjectmethod", vm_objectmethod, free_},
+                      {L"classmethod", vm_classfreemethod, free_},
+                      {L"objectmethod", vm_objectfreemethod, free_},
+                      {L"simplemethod", vm_allfreemethod, free_},
+                      {L"simplestaticmethod", vm_allstaticmethod, free_},
+                      {L"quit", vm_quit, free_},
                       {NULL, NULL}};
     iterBaseNameFunc(tmp, belong, CALL_INTER_FUNCTIONSIG_CORE(var_list));
 }

VirtulMathCore/ofunc/src/vobject.c

@@ -56,7 +56,7 @@ ResultType vobject_opt_core(OFFICAL_FUNCTIONSIG, base_opt func){
     Value *left = NULL;
     Value *right = NULL;
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
-                           {.type=name_value, .name="right", .must=1, .long_arg=false},
+                           {.type=name_value, .name=L"right", .must=1, .long_arg=false},
                            {.must=-1}};
     setResultCore(result);
     {
@@ -193,7 +193,7 @@ void registeredVObject(REGISTERED_FUNCTIONSIG){
                       {inter->data.object_str, vobject_repo, object_free_},
                       {NULL, NULL}};
     gc_addTmpLink(&object->gc_status);
-    addBaseClassVar("vobject", object, belong, inter);
+    addBaseClassVar(L"vobject", object, belong, inter);
     iterBaseClassFunc(tmp, object, CALL_INTER_FUNCTIONSIG_CORE(inter->var_list));
     gc_freeTmpLink(&object->gc_status);
 }

VirtulMathCore/parser/grammar.c

@@ -1376,10 +1376,8 @@ void parserBaseValue(PASERSSIGNATURE){
             if (*value_token->data.second_str == NUL)
                 st = tmp;
             else {
-                char *ch = wcsToStr(value_token->data.second_str, false);
-                Statement *second_var = makeBaseVarStatement(ch, NULL, value_token->line, pm->file);
+                Statement *second_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line, pm->file);
                 st = makeCallStatement(second_var, makeValueParameter(tmp));
-                memFree(ch);
             }
             break;
         }
@@ -1390,10 +1388,8 @@ void parserBaseValue(PASERSSIGNATURE){
             if (*value_token->data.second_str == NUL)
                 st = tmp;
             else {
-                char *ch = wcsToStr(value_token->data.second_str, false);
-                Statement *sencod_var = makeBaseVarStatement(ch, NULL, value_token->line, pm->file);
+                Statement *sencod_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line, pm->file);
                 st = makeCallStatement(sencod_var, makeValueParameter(tmp));
-                memFree(ch);
             }
             break;
         }
@@ -1431,12 +1427,9 @@ void parserBaseValue(PASERSSIGNATURE){
             st = makeLambdaStatement(lambda_st, pt);
             break;
         }
-        case MATHER_VAR: {
-            char *ch = wcsToStr(value_token->data.str, false);
-            st = makeBaseVarStatement(ch, NULL, value_token->line, pm->file);
-            memFree(ch);
+        case MATHER_VAR:
+            st = makeBaseVarStatement(value_token->data.str, NULL, value_token->line, pm->file);
             break;
-        }
         case MATHER_SVAR: {
             Statement *svar_st = NULL;
             if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &svar_st, NULL)) {
@@ -1464,12 +1457,9 @@ void parserBaseValue(PASERSSIGNATURE){
             }
             if (MATHER_VAR == readBackToken(pm)) {
                 Token *var_token;
-                char *ch;
                 var_token = popNewToken(pm->tm);
-                ch =  wcsToStr(var_token->data.str, false);
-                st = makeBaseVarStatement(ch, tmp_st, var_token->line, pm->file);
+                st = makeBaseVarStatement(var_token->data.str, tmp_st, var_token->line, pm->file);
                 freeToken(var_token, false);
-                memFree(ch);
             } else {
                 if (tmp_st == NULL)
                     st = makeTupleStatement(NULL, value_list, value_token->line, pm->file);

VirtulMathCore/src/__run.c

@@ -1,9 +1,6 @@
 #include "__run.h"
 
-
-ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
-    wchar_t *wcs_name;
-
+ResultType getBaseVarInfo(wchar_t **name, int *times, INTER_FUNCTIONSIG){
     *name = setStrVarName(st->u.base_var.name, false, inter);
     *times = 0;
     if (st->u.base_var.times == NULL){
@@ -20,13 +17,11 @@ ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     freeResult(result);
 
     not_times:
-    wcs_name = strToWcs(st->u.base_var.name, false);
-    makeStringValue(wcs_name, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    memFree(wcs_name);
+    makeStringValue(st->u.base_var.name, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     return result->type;
 }
 
-ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
+ResultType getBaseSVarInfo(wchar_t **name, int *times, INTER_FUNCTIONSIG){
     freeResult(result);
 
     if (st->u.base_svar.times == NULL){
@@ -52,7 +47,7 @@ ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     return result->type;
 }
 
-ResultType getVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
+ResultType getVarInfo(wchar_t **name, int *times, INTER_FUNCTIONSIG){
     if (st->type == base_var)
         getBaseVarInfo(name, times, CALL_INTER_FUNCTIONSIG(st, var_list, result, belong));
     else if (st->type == base_svar)
@@ -66,46 +61,46 @@ ResultType getVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     return result->type;
 }
 
-char *setStrVarName(char *old, bool free_old, Inter *inter) {
-    return memStrcat(inter->data.var_str_prefix, old, false, free_old);
+wchar_t *setStrVarName(wchar_t *old, bool free_old, Inter *inter) {
+    return memWidecat(inter->data.var_str_prefix, old, false, free_old);
 }
 
-char *setNumVarName(vnum num, struct Inter *inter) {
-    char name[50];
-    snprintf(name, 50, "%lld", num);
-    return memStrcat(inter->data.var_num_prefix, name, false, false);
+wchar_t *setNumVarName(vnum num, struct Inter *inter) {
+    wchar_t name[50];
+    swprintf(name, 50, L"%lld", num);
+    return memWidecat(inter->data.var_num_prefix, name, false, false);
 }
 
-char *getNameFromValue(Value *value, struct Inter *inter) {
+wchar_t *getNameFromValue(Value *value, struct Inter *inter) {
     switch (value->type){
         case string:
-            return setStrVarName(wcsToStr(value->data.str.str, false), true, inter);  // TODO-szh VAR使用宽字符
+            return setStrVarName(value->data.str.str, true, inter);  // TODO-szh VAR使用宽字符
         case number:
             return setNumVarName(value->data.num.num, inter);
         case bool_:
             if (value->data.bool_.bool_)
-                return memStrcat(inter->data.var_bool_prefix, "true", false, false);
+                return memWidecat(inter->data.var_bool_prefix, L"true", false, false);
             else
-                return memStrcat(inter->data.var_bool_prefix, "false", false, false);
+                return memWidecat(inter->data.var_bool_prefix, L"false", false, false);
         case none:
-            return memStrcpy(inter->data.var_none);
+            return memWidecpy(inter->data.var_none);
         case pass_:
-            return memStrcpy(inter->data.var_pass);
+            return memWidecpy(inter->data.var_pass);
         case class:{
-            size_t len = memStrlen(inter->data.var_class_prefix) + 20;
-            char *name = memString(len);
-            char *return_ = NULL;
-            snprintf(name, len, "%s%p", inter->data.var_class_prefix, value);
-            return_ = memStrcpy(name);
+            size_t len = memWidelen(inter->data.var_class_prefix) + 20;  // 预留20个字节给指针
+            wchar_t *name = memWide(len);
+            wchar_t *return_ = NULL;
+            swprintf(name, len, L"%ls%p", inter->data.var_class_prefix, value);
+            return_ = memWidecpy(name);  // 再次复制去除多余的空字节
             memFree(name);
             return return_;
         }
         default:{
-            size_t len = memStrlen(inter->data.var_object_prefix) + 20;
-            char *name = memString(len);
-            char *return_ = NULL;
-            snprintf(name, len, "%s%p", inter->data.var_object_prefix, value);
-            return_ = memStrcpy(name);
+            size_t len = memWidelen(inter->data.var_object_prefix) + 20;
+            wchar_t *name = memWide(len);
+            wchar_t *return_ = NULL;
+            swprintf(name, len, L"%ls%p", inter->data.var_object_prefix, value);
+            return_ = memWidecpy(name);  // 再次复制去除多余的空字节
             memFree(name);
             return return_;
         }
@@ -274,23 +269,23 @@ void freeFunctionArgument(Argument *arg, Argument *base) {
     }
 }
 
-LinkValue *findStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE){
+LinkValue *findStrVar(wchar_t *name, bool free_old, INTER_FUNCTIONSIG_CORE){
     LinkValue *tmp = NULL;
-    char *name_ = setStrVarName(name, free_old, inter);
+    wchar_t *name_ = setStrVarName(name, free_old, inter);
     tmp = findFromVarList(name_, 0, get_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     memFree(name_);
     return tmp;
 }
 
-LinkValue *checkStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE){
+LinkValue *checkStrVar(wchar_t *name, bool free_old, INTER_FUNCTIONSIG_CORE){
     LinkValue *tmp = NULL;
-    char *name_ = setStrVarName(name, free_old, inter);
+    wchar_t *name_ = setStrVarName(name, free_old, inter);
     tmp = findFromVarList(name_, 0, read_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     memFree(name_);
     return tmp;
 }
 
-void addStrVarCore(int setting, char *var_name, LinkValue *name_, LinkValue *value, fline line, char *file, VarList *out_var, INTER_FUNCTIONSIG_NOT_ST) {
+void addStrVarCore(int setting, wchar_t *var_name, LinkValue *name_, LinkValue *value, fline line, char *file, VarList *out_var, INTER_FUNCTIONSIG_NOT_ST) {
     addFromVarList(var_name, name_, 0, value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     out_var = out_var == NULL ? var_list : out_var;
     if (setting)
@@ -299,13 +294,12 @@ void addStrVarCore(int setting, char *var_name, LinkValue *name_, LinkValue *val
         setResult(result, inter, belong);
 }
 
-void addStrVar(char *name, bool free_old, bool setting, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
+void addStrVar(wchar_t *name, bool free_old, bool setting, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
     LinkValue *name_;
-    char *var_name = setStrVarName(name, free_old, inter);
-    wchar_t *wcs_name = strToWcs(name, false);
+    wchar_t *var_name = setStrVarName(name, free_old, inter);
     setResultCore(result);
 
-    makeStringValue(wcs_name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    makeStringValue(var_name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         goto return_;
 
@@ -317,24 +311,22 @@ void addStrVar(char *name, bool free_old, bool setting, LinkValue *value, fline
 
     gc_freeTmpLink(&name_->gc_status);
     return_:
-    memFree(wcs_name);
     memFree(var_name);
 }
 
-LinkValue *findAttributes(char *name, bool free_old, LinkValue *value, Inter *inter) {
+LinkValue *findAttributes(wchar_t *name, bool free_old, LinkValue *value, Inter *inter) {
     LinkValue *attr = findStrVar(name, free_old, CALL_INTER_FUNCTIONSIG_CORE(value->value->object.var));
     if (attr != NULL && (attr->belong == NULL || attr->belong->value != value->value && checkAttribution(value->value, attr->belong->value)))
         attr->belong = value;
     return attr;
 }
 
-bool addAttributes(char *name, bool free_old, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
-    char *var_name = setStrVarName(name, free_old, inter);
-    wchar_t *wcs_name = strToWcs(name, false);
+bool addAttributes(wchar_t *name, bool free_old, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
+    wchar_t *var_name = setStrVarName(name, free_old, inter);
     LinkValue *name_;
     setResultCore(result);
 
-    makeStringValue(wcs_name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    makeStringValue(var_name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         goto return_;
 
@@ -349,7 +341,6 @@ bool addAttributes(char *name, bool free_old, LinkValue *value, fline line, char
     gc_freeTmpLink(&name_->gc_status);
     return_:
     memFree(var_name);
-    memFree(wcs_name);
     return CHECK_RESULT(result);
 }
 
@@ -506,7 +497,7 @@ int init_new(LinkValue *obj, Argument *arg, char *message, INTER_FUNCTIONSIG_NOT
     return CHECK_RESULT(result) ? 1 : -1;
 }
 
-bool setBoolAttrible(bool value, char *var, fline line, char *file, LinkValue *obj, INTER_FUNCTIONSIG_NOT_ST) {
+bool setBoolAttrible(bool value, wchar_t *var, fline line, char *file, LinkValue *obj, INTER_FUNCTIONSIG_NOT_ST) {
     LinkValue *bool_value = NULL;
     setResultCore(result);
     makeBoolValue(value, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));

VirtulMathCore/src/include/__run.h

@@ -2,12 +2,12 @@
 #define VIRTUALMATH___RUN_H
 #include "__virtualmath.h"
 
-char *setStrVarName(char *old, bool free_old, struct Inter *inter);
-char *setNumVarName(vnum num, struct Inter *inter);
-char *getNameFromValue(Value *value, struct Inter *inter);
-ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
-ResultType getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
-ResultType getVarInfo(char **name, int *times, INTER_FUNCTIONSIG);
+wchar_t *setStrVarName(wchar_t *old, bool free_old, struct Inter *inter);
+wchar_t *setNumVarName(vnum num, struct Inter *inter);
+wchar_t *getNameFromValue(Value *value, struct Inter *inter);
+ResultType getBaseVarInfo(wchar_t **name, int *times, INTER_FUNCTIONSIG);
+ResultType getBaseSVarInfo(wchar_t **name, int *times, INTER_FUNCTIONSIG);
+ResultType getVarInfo(wchar_t **name, int *times, INTER_FUNCTIONSIG);
 
 bool popStatementVarList(Statement *funtion_st, VarList **function_var, VarList *out_var, Inter *inter);
 
@@ -22,12 +22,12 @@ void newForBranchYield(Statement *branch_st, Statement *node, StatementList *sl_
 
 ResultType setFunctionArgument(struct Argument **arg, struct Argument **base, LinkValue *_func, fline line, char *file, int pt_sep, INTER_FUNCTIONSIG_NOT_ST);
 void freeFunctionArgument(Argument *arg, Argument *base);
-LinkValue *findStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE);
-LinkValue *checkStrVar(char *name, bool free_old, INTER_FUNCTIONSIG_CORE);
-void addStrVar(char *name, bool free_old, bool setting, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
-LinkValue *findAttributes(char *name, bool free_old, LinkValue *value, Inter *inter);
+LinkValue *findStrVar(wchar_t *name, bool free_old, INTER_FUNCTIONSIG_CORE);
+LinkValue *checkStrVar(wchar_t *name, bool free_old, INTER_FUNCTIONSIG_CORE);
+void addStrVar(wchar_t *name, bool free_old, bool setting, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+LinkValue *findAttributes(wchar_t *name, bool free_old, LinkValue *value, Inter *inter);
 
-bool addAttributes(char *name, bool free_old, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+bool addAttributes(wchar_t *name, bool free_old, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 void newObjectSetting(LinkValue *name, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 ResultType getElement(LinkValue *from, LinkValue *index, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 ResultType getIter(LinkValue *value, int status, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
@@ -38,5 +38,5 @@ bool is_indexException(LinkValue *value, Inter *inter);
 bool checkAut(enum ValueAuthority value, enum ValueAuthority base, fline line, char *file, char *name, bool pri_auto, INTER_FUNCTIONSIG_NOT_ST);
 LinkValue *make_new(Inter *inter, LinkValue *belong, LinkValue *class);
 int init_new(LinkValue *obj, Argument *arg, char *message, INTER_FUNCTIONSIG_NOT_ST);
-bool setBoolAttrible(bool value, char *var, fline line, char *file, LinkValue *obj, INTER_FUNCTIONSIG_NOT_ST);
+bool setBoolAttrible(bool value, wchar_t *var, fline line, char *file, LinkValue *obj, INTER_FUNCTIONSIG_NOT_ST);
 #endif //VIRTUALMATH___RUN_H

VirtulMathCore/src/inter.c

@@ -1,4 +1,5 @@
 #include "__virtualmath.h"
+#define setName(str) strToWcs(str, false);
 
 Inter *makeInter(char *out, char *error_, char *in, LinkValue *belong) {
     Inter *tmp = memCalloc(1, sizeof(Inter));
@@ -52,38 +53,38 @@ Inter *makeInter(char *out, char *error_, char *in, LinkValue *belong) {
 }
 
 void setBaseInterData(struct Inter *inter){
-    inter->data.var_str_prefix = memStrcpy("str_");
-    inter->data.var_num_prefix = memStrcpy("num_");
-    inter->data.var_none = memStrcpy("none");
-    inter->data.var_pass = memStrcpy("ellipsis");
-    inter->data.var_bool_prefix = memStrcpy("bool_");
-    inter->data.var_class_prefix = memStrcpy("class_");
-    inter->data.var_object_prefix = memStrcpy("obj_");
-    inter->data.object_init = memStrcpy("__init__");
-    inter->data.object_enter = memStrcpy("__enter__");
-    inter->data.object_exit = memStrcpy("__exit__");
-    inter->data.object_new = memStrcpy("__new__");
-    inter->data.object_add = memStrcpy("__add__");
-    inter->data.object_sub = memStrcpy("__sub__");
-    inter->data.object_mul = memStrcpy("__mul__");
-    inter->data.object_div = memStrcpy("__div__");
-    inter->data.object_call = memStrcpy("__call__");
-    inter->data.object_del = memStrcpy("__del__");
-    inter->data.object_down = memStrcpy("__down__");
-    inter->data.object_slice = memStrcpy("__slice__");
-    inter->data.object_iter = memStrcpy("__iter__");
-    inter->data.object_next = memStrcpy("__next__");
-    inter->data.object_repo = memStrcpy("__repo__");
-    inter->data.object_bool = memStrcpy("__bool__");
-    inter->data.object_self = memStrcpy("__self__");
-    inter->data.object_name = memStrcpy("__name__");
-    inter->data.object_father = memStrcpy("__father__");
-    inter->data.object_message = memStrcpy("__message__");
-    inter->data.object_str = memStrcpy("__str__");
-    inter->data.object_down_assignment = memStrcpy("__down_assignment__");
-    inter->data.object_slice_assignment = memStrcpy("__slice_assignment__");
-    inter->data.object_down_del = memStrcpy("__down_del__");
-    inter->data.object_slice_del = memStrcpy("__slice_del__");
+    inter->data.var_str_prefix = setName("str_");
+    inter->data.var_num_prefix = setName("num_");
+    inter->data.var_none = setName("none");
+    inter->data.var_pass = setName("ellipsis");
+    inter->data.var_bool_prefix = setName("bool_");
+    inter->data.var_class_prefix = setName("class_");
+    inter->data.var_object_prefix = setName("obj_");
+    inter->data.object_init = setName("__init__");
+    inter->data.object_enter = setName("__enter__");
+    inter->data.object_exit = setName("__exit__");
+    inter->data.object_new = setName("__new__");
+    inter->data.object_add = setName("__add__");
+    inter->data.object_sub = setName("__sub__");
+    inter->data.object_mul = setName("__mul__");
+    inter->data.object_div = setName("__div__");
+    inter->data.object_call = setName("__call__");
+    inter->data.object_del = setName("__del__");
+    inter->data.object_down = setName("__down__");
+    inter->data.object_slice = setName("__slice__");
+    inter->data.object_iter = setName("__iter__");
+    inter->data.object_next = setName("__next__");
+    inter->data.object_repo = setName("__repo__");
+    inter->data.object_bool = setName("__bool__");
+    inter->data.object_self = setName("__self__");
+    inter->data.object_name = setName("__name__");
+    inter->data.object_father = setName("__father__");
+    inter->data.object_message = setName("__message__");
+    inter->data.object_str = setName("__str__");
+    inter->data.object_down_assignment = setName("__down_assignment__");
+    inter->data.object_slice_assignment = setName("__slice_assignment__");
+    inter->data.object_down_del = setName("__down_del__");
+    inter->data.object_slice_del = setName("__slice_del__");
     inter->data.default_pt_type = free_;
 }
 
@@ -325,7 +326,7 @@ void printVarGC(char *tag, Inter *inter){
             printf("inter->link_base.link           = %ld :: %p\n", base->gc_status.link, base);
         }
 
-        printf("str_name = %s\n", base->name);
+        printf("str_name = %ls\n", base->name);
         printf("name = ");
         printValue(base->name_->value, stdout, false, true);
         printf("\nvalue = ");
@@ -362,7 +363,7 @@ void printToken(Token *tk) {
         if (eqWide(tmp,  L"\n"))
             tmp = L"\\n";
         if (eqWide(second_tmp, L"\n"))
-            second_tmp = (wchar_t *)L"\\n";
+            second_tmp = L"\\n";
         printf("<token str = ('%ls','%ls'), type = %d>", tmp, second_tmp, tk->token_type);
     }
     else

VirtulMathCore/src/parameter.c

@@ -34,12 +34,12 @@ Argument *makeStatementNameArgument(LinkValue *value, Statement *name){
     return tmp;
 }
 
-Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, char *name) {
+Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, wchar_t *name) {
     Argument *tmp = makeArgument();
     tmp->type = name_arg;
     tmp->name_type = name_char;
     tmp->data.value = value;
-    tmp->data.name_ = memStrcpy(name);
+    tmp->data.name_ = memWidecpy(name);
     tmp->data.name_value = name_value;
     gc_addTmpLink(&value->gc_status);
     gc_addTmpLink(&name_value->gc_status);
@@ -66,7 +66,7 @@ Argument *connectStatementNameArgument(LinkValue *value, Statement *name, Argume
     return connectArgument(new, base);
 }
 
-Argument *connectCharNameArgument(LinkValue *value, LinkValue *name_value, char *name, Argument *base) {
+Argument *connectCharNameArgument(LinkValue *value, LinkValue *name_value, wchar_t *name, Argument *base) {
     Argument *new = makeCharNameArgument(value, name_value, name);
     return connectArgument(new, base);
 }
@@ -225,7 +225,7 @@ Argument *dictToArgument(LinkValue *dict_value, long line, char *file, INTER_FUN
     result->value = NULL;
     while (true) {
         LinkValue *name_ = NULL;
-        char *name = NULL;
+        wchar_t *name = NULL;
 
         freeResult(result);
         getIter(iter, 0, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -340,7 +340,7 @@ ResultType parameterFromVar(Parameter **function_ad, VarList *function_var, vnum
 
     for (*num = 0, *status = false; function != NULL; function = function->next){
         int int_times;
-        char *str_name = NULL;
+        wchar_t *str_name = NULL;
         Statement *name = function->type == name_par ? function->data.name : function->data.value;
         LinkValue *value = NULL;
         get = true;
@@ -458,7 +458,7 @@ ResultType iterParameter(Parameter *call, Argument **base_ad, bool is_dict, INTE
                     gc_freeTmpLink(&value->gc_status);
                     goto return_;
                 }
-                char *name_str = getNameFromValue(result->value->value, inter);
+                wchar_t *name_str = getNameFromValue(result->value->value, inter);
                 base = connectCharNameArgument(value, result->value, name_str, base);
                 memFree(name_str);
                 gc_freeTmpLink(&value->gc_status);
@@ -828,7 +828,8 @@ Argument *parserArgumentValueCore(Argument *arg, ArgumentParser *ap){
 }
 
 int parserArgumentVar(ArgumentParser *ap, Inter *inter, VarList *var_list){
-    LinkValue *value = findStrVar(ap->name, false, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    LinkValue *value = NULL;
+    findStrVar(ap->name, false, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     ap->value = value;
     if (value != NULL)
         return 1;

VirtulMathCore/src/runcall.c

@@ -113,7 +113,7 @@ ResultType setLambda(INTER_FUNCTIONSIG) {
 ResultType elementSlice(INTER_FUNCTIONSIG) {
     LinkValue *element = NULL;
     LinkValue *_func_ = NULL;
-    char *func_name = NULL;
+    wchar_t *func_name = NULL;
     setResultCore(result);
     if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.slice_.element, var_list, result, belong)))
         return result->type;

VirtulMathCore/src/runfile.c

@@ -253,8 +253,11 @@ ResultType importFile(INTER_FUNCTIONSIG) {
     if (!getPackage(&imp_value, md5_str, split_path, status, &path, &is_new, is_lock, CALL_INTER_FUNCTIONSIG(file, var_list, result, belong)))
         goto return_;
     freeResult(result);
-    if (st->u.import_file.as == NULL)
-        addStrVar(split_path, false, is_new, imp_value, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    if (st->u.import_file.as == NULL) {
+        wchar_t *name_ = strToWcs(split_path, false);
+        addStrVar(name_, false, is_new, imp_value, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+        memFree(name_);
+    }
     else
         assCore(st->u.import_file.as, imp_value, false, is_new, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
 

VirtulMathCore/src/runoperation.c

@@ -1,7 +1,7 @@
 #include "__run.h"
 
 static bool getLeftRightValue(Result *left, Result *right, INTER_FUNCTIONSIG);
-static ResultType operationCore(INTER_FUNCTIONSIG, char *name);
+static ResultType operationCore(INTER_FUNCTIONSIG, wchar_t *name);
 ResultType assOperation(INTER_FUNCTIONSIG);
 ResultType pointOperation(INTER_FUNCTIONSIG);
 ResultType blockOperation(INTER_FUNCTIONSIG);
@@ -139,7 +139,7 @@ ResultType listDel(Statement *name, INTER_FUNCTIONSIG_NOT_ST) {
 }
 
 ResultType varDel(Statement *name, bool check_aut, INTER_FUNCTIONSIG_NOT_ST) {
-    char *str_name = NULL;
+    wchar_t *str_name = NULL;
     int int_times = 0;
     setResultCore(result);
     getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list, result, belong));
@@ -274,7 +274,7 @@ ResultType assCore(Statement *name, LinkValue *value, bool check_aut, bool setti
 
 
 ResultType varAss(Statement *name, LinkValue *value, bool check_aut, bool setting, INTER_FUNCTIONSIG_NOT_ST) {
-    char *str_name = NULL;
+    wchar_t *str_name = NULL;
     int int_times = 0;
     LinkValue *var_value = NULL;
 
@@ -406,7 +406,7 @@ ResultType pointAss(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_NOT_ST)
 
 ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
     int int_times = 0;
-    char *name = NULL;
+    wchar_t *name = NULL;
     LinkValue *var;
 
     setResultCore(result);
@@ -419,7 +419,7 @@ ResultType getVar(INTER_FUNCTIONSIG, VarInfo var_info) {
     freeResult(result);
     var = findFromVarList(name, int_times, get_var, CALL_INTER_FUNCTIONSIG_CORE(var_list));
     if (var == NULL) {
-        char *info = memStrcat("Variable not found: ", name, false, false);
+        char *info = memStrcat("Variable not found: ", wcsToStr(name, false), false, true);
         setResultErrorSt(E_NameExceptiom, info, true, st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         memFree(info);
     }
@@ -513,7 +513,7 @@ ResultType setDefault(INTER_FUNCTIONSIG){
     else if (type == nonlocal_)
         base = 1;
     for (Parameter *pt = st->u.default_var.var; pt != NULL; pt = pt->next){
-        char *name = NULL;
+        wchar_t *name = NULL;
         int times = 0;
         freeResult(result);
         getVarInfo(&name, &times, CALL_INTER_FUNCTIONSIG(pt->data.value, var_list, result, belong));
@@ -540,7 +540,7 @@ bool getLeftRightValue(Result *left, Result *right, INTER_FUNCTIONSIG){
     return false;
 }
 
-ResultType operationCore(INTER_FUNCTIONSIG, char *name) {
+ResultType operationCore(INTER_FUNCTIONSIG, wchar_t *name) {
     Result left;
     Result right;
     LinkValue *_func_ = NULL;
@@ -560,7 +560,7 @@ ResultType operationCore(INTER_FUNCTIONSIG, char *name) {
         freeArgument(arg, true);
     }
     else {
-        char *message = memStrcat("Object not support ", name, false, false);
+        char *message = memStrcat("Object not support ", wcsToStr(name, false), false, true);
         setResultErrorSt(E_TypeException, message, true, st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         memFree(message);
     }

VirtulMathCore/src/statement.c

@@ -92,10 +92,10 @@ Statement *makeBaseValueStatement(enum BaseValueType type, fline line, char *fil
     return tmp;
 }
 
-Statement *makeBaseVarStatement(char *name, Statement *times, fline line, char *file){
+Statement *makeBaseVarStatement(wchar_t *name, Statement *times, fline line, char *file){
     Statement *tmp = makeStatement(line, file);
     tmp->type = base_var;
-    tmp->u.base_var.name = memStrcpy(name);
+    tmp->u.base_var.name = memWidecpy(name);
     tmp->u.base_var.times = times;
     return tmp;
 }
@@ -536,7 +536,7 @@ Statement *copyStatementCore(Statement *st){
             new->u.operation.left = copyStatement(st->u.operation.left);
             break;
         case base_var:
-            new->u.base_var.name = memStrcpy(st->u.base_var.name);
+            new->u.base_var.name = memWidecpy(st->u.base_var.name);
             new->u.base_var.times = copyStatement(st->u.base_var.times);
             break;
         case del_:

VirtulMathCore/src/value.c

@@ -284,7 +284,7 @@ void setResultBase(Result *ru, Inter *inter) {
     useNoneValue(inter, ru);
 }
 
-void setResultErrorSt(BaseErrorType type, char *error_message, bool new, Statement *st, INTER_FUNCTIONSIG_NOT_ST) {
+void setResultErrorSt(BaseErrorType type, char *error_message, bool new, Statement *st, INTER_FUNCTIONSIG_NOT_ST) {  // TODO-szh 支持宽字符
     setResultError(type, error_message, st->line, st->code_file, new, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
 }
 
@@ -334,7 +334,7 @@ LinkValue *findBaseError(BaseErrorType type, Inter *inter){
 }
 
 char *getErrorInfo(LinkValue *exc, int type, Inter *inter){
-    char *str_name = type == 1 ? inter->data.object_name : inter->data.object_message;
+    wchar_t *str_name = type == 1 ? inter->data.object_name : inter->data.object_message;
     LinkValue *_info_ = findAttributes(str_name, false, exc, inter);
     if (_info_ != NULL && _info_->value->type == string)
         return wcsToStr(_info_->value->data.str.str, false);  // TODO-szh var使用宽字符
@@ -647,7 +647,7 @@ void printValue(Value *value, FILE *debug, bool print_father, bool print_in) {
                         else
                             print_comma = true;
                         printValue(tmp->name_->value, debug, false, false);
-                        fprintf(debug, " ['%s'] : ", tmp->name);
+                        fprintf(debug, " ['%ls'] : ", tmp->name);
                         printValue(tmp->value->value, debug, false, false);
                     }
                 }

VirtulMathCore/src/var.c

@@ -1,11 +1,11 @@
 #include "__virtualmath.h"
 
-Var *makeVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter) {
+Var *makeVar(wchar_t *name, LinkValue *value, LinkValue *name_, Inter *inter) {
     Var *list_tmp = inter->base_var;
     Var *tmp;
     tmp = memCalloc(1, sizeof(Var));
     setGC(&tmp->gc_status);
-    tmp->name = memStrcpy(name);
+    tmp->name = memWidecpy(name);
     tmp->value = copyLinkValue(value, inter);
     tmp->name_ = copyLinkValue(name_, inter);
     tmp->next = NULL;
@@ -100,10 +100,10 @@ VarList *freeVarList(VarList *vl) {
     return next_var;
 }
 
-DefaultVar *makeDefaultVar(char *name, vnum times) {
+DefaultVar *makeDefaultVar(wchar_t *name, vnum times) {
     DefaultVar *tmp;
     tmp = memCalloc(1, sizeof(DefaultVar));
-    tmp->name = memStrcpy(name);
+    tmp->name = memWidecpy(name);
     tmp->times = times;
     tmp->next = NULL;
     return tmp;
@@ -116,13 +116,13 @@ DefaultVar *freeDefaultVar(DefaultVar *dv) {
     return next;
 }
 
-DefaultVar *connectDefaultVar(DefaultVar *base, char *name, vnum times) {
+DefaultVar *connectDefaultVar(DefaultVar *base, wchar_t *name, vnum times) {
     for (DefaultVar **tmp = &base; PASS; tmp = &(*tmp)->next){
         if (*tmp == NULL){
             *tmp = makeDefaultVar(name, times);
             break;
         }
-        if (eqString((*tmp)->name, name)){
+        if (eqWide((*tmp)->name, name)){
             (*tmp)->times = times;
             break;
         }
@@ -130,9 +130,9 @@ DefaultVar *connectDefaultVar(DefaultVar *base, char *name, vnum times) {
     return base;
 }
 
-vnum findDefault(DefaultVar *base, char *name) {
+vnum findDefault(DefaultVar *base, wchar_t *name) {
     for (DefaultVar **tmp = &base; *tmp != NULL; tmp = &(*tmp)->next)
-        if (eqString((*tmp)->name, name))
+        if (eqWide((*tmp)->name, name))
             return (*tmp)->times;
     return 0;
 }
@@ -142,19 +142,19 @@ vnum findDefault(DefaultVar *base, char *name) {
  * @param key
  * @return
  */
-vhashn time33(char *key){ // hash function
+vhashn time33(wchar_t *key){ // hash function
     vhashn hash = 5381;
     while(*key)
         hash += (hash << (vhashn)5) + (*key++);
     return (hash & (vhashn)0x7FFFFFFF) % MAX_SIZE;
 }
 
-static void addVarCore(Var **base, char *name, LinkValue *value, LinkValue *name_, Inter *inter) {
+static void addVarCore(Var **base, wchar_t *name, LinkValue *value, LinkValue *name_, Inter *inter) {
     for (PASS; true; base = &(*base)->next) {
         if (*base == NULL) {
             *base = makeVar(name, value, name_, inter);
             break;
-        } else if (eqString((*base)->name, name)) {
+        } else if (eqWide((*base)->name, name)) {
             (*base)->value->value = value->value;
             (*base)->value->belong = value->belong;
             break;
@@ -162,7 +162,7 @@ static void addVarCore(Var **base, char *name, LinkValue *value, LinkValue *name
     }
 }
 
-void addVar(char *name, LinkValue *value, LinkValue *name_, Inter *inter, HashTable *ht) {
+void addVar(wchar_t *name, LinkValue *value, LinkValue *name_, Inter *inter, HashTable *ht) {
     vhashn index = time33(name);
     addVarCore(&ht->hashtable[index], name, value, name_, inter);
 }
@@ -174,11 +174,11 @@ void updateHashTable(HashTable *update, HashTable *new, Inter *inter) {
 }
 
 
-LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *ht) {
+LinkValue *findVar(wchar_t *name, VarOperation operating, Inter *inter, HashTable *ht) {
     LinkValue *tmp = NULL;
     vhashn index = time33(name);
     for (Var **base = &ht->hashtable[index]; *base != NULL; base = &(*base)->next){
-        if (eqString((*base)->name, name)){
+        if (eqWide((*base)->name, name)){
             tmp = (*base)->value;
             if (operating == del_var) {
                 Var *next = (*base)->next;
@@ -199,7 +199,7 @@ LinkValue *findVar(char *name, VarOperation operating, Inter *inter, HashTable *
  * @param var_list
  * @return
  */
-LinkValue *findFromVarList(char *name, vnum times, VarOperation operating, INTER_FUNCTIONSIG_CORE) {
+LinkValue *findFromVarList(wchar_t *name, vnum times, VarOperation operating, INTER_FUNCTIONSIG_CORE) {
     LinkValue *tmp = NULL;
     vnum base = findDefault(var_list->default_var, name) + times;
     for (vnum i = 0; i < base && var_list->next != NULL; i++)
@@ -212,7 +212,7 @@ LinkValue *findFromVarList(char *name, vnum times, VarOperation operating, INTER
     return tmp;
 }
 
-void addFromVarList(char *name, LinkValue *name_, vnum times, LinkValue *value, INTER_FUNCTIONSIG_CORE) {
+void addFromVarList(wchar_t *name, LinkValue *name_, vnum times, LinkValue *value, INTER_FUNCTIONSIG_CORE) {
     vnum base = findDefault(var_list->default_var, name) + times;
     for (vnum i = 0; i < base && var_list->next != NULL; i++)
         var_list = var_list->next;