feat: 字符串和匹配器使用宽字符

字符串使用wchar_t
parser模块使用宽字符
memory中添加了对宽字符的支持

link #8

VirtulMathCore/include/lexical.h

@@ -7,7 +7,7 @@ struct LexFile{
     bool is_std;  // 是否位stdin
     struct LexFileBack{
         bool is_back;
-        int p;
+        wint_t p;
     } back;
     struct {
         int enter;  // 若计数为0则不忽略enter
@@ -17,9 +17,9 @@ struct LexFile{
 
 struct LexMather{
     int len;
-    int string_type;
-    char *str;
-    char *second_str;
+    wint_t string_type;
+    wchar_t *str;
+    wchar_t *second_str;
     int ascii;
     enum LexMatherStatus{
         LEXMATHER_START=1,
@@ -44,7 +44,7 @@ typedef struct LexFile LexFile;
 typedef struct LexMather LexMather;
 typedef struct LexMathers LexMathers;
 
-int readChar(LexFile *file);
+wint_t readChar(LexFile *file);
 void backChar(LexFile *file);
 void clearLexFile(LexFile *file);
 

VirtulMathCore/include/macro.h

@@ -13,6 +13,7 @@
 #include <signal.h>
 #include <unistd.h>
 #include <wchar.h>
+#include <wctype.h>
 #include <locale.h>
 
 #ifdef __linux__

VirtulMathCore/include/mem.h

@@ -9,15 +9,25 @@ extern bool memVirtualMathUseJmp;
 void *memCalloc(size_t num, size_t size);
 void *memRealloc(void *old, size_t size);
 char *memStrcpy(const char *str);
+wchar_t *memWidecpy(const wchar_t *str);
 char *memStrCharcpy(char *str, size_t nsize, bool free_old, bool write, ...);
+wchar_t *memWideCharcpy(wchar_t *str, size_t nsize, bool free_old, bool write, ...);
 char *memStrcatIter(char *base, bool free_base, ...);
 char *memStrcat(char *first, char *second, bool free_first, bool free_last);
+wchar_t *memWidecat(wchar_t *first, wchar_t *second, bool free_first, bool free_last);
 char *memStrcpySelf(char *str, long times);
+wchar_t *memWidecpySelf(wchar_t *str, long times);
 char *memStrrev(const char *str);
+wchar_t *memWiderev(wchar_t *str);
+char *wcsToStr(wchar_t *wcs, bool free_old);
+wchar_t *strToWcs(char *str, bool free_old);
 
 #define memFree(p) ((p)=((p) != NULL ? (free(p), NULL) : NULL))
 #define eqString(str1, str2) (!strcmp(str1, str2))
+#define eqWide(wid1, wid2) (!wcscmp(wid1, wid2))
 #define memString(size) (char *)memCalloc(size + 1, sizeof(char))
+#define memWide(size) (wchar_t *)memCalloc(size + 1, sizeof(wchar_t))
 #define memStrlen(p) (((p) == NULL) ? 0 :strlen(p))
+#define memWidelen(p) (((p) == NULL) ? 0 :wcslen(p))
 
 #endif //VIRTUALMATH_MEM_H

VirtulMathCore/include/run.h

@@ -23,7 +23,7 @@ bool functionSafeInterStatement(INTER_FUNCTIONSIG);
 bool blockSafeInterStatement(INTER_FUNCTIONSIG);
 bool cycleBranchSafeInterStatement(INTER_FUNCTIONSIG);
 bool tryBranchSafeInterStatement(INTER_FUNCTIONSIG);
-Statement *checkLabel(Statement *base, char *label);
+Statement *checkLabel(Statement *base, wchar_t *label);
 
 ResultType operationStatement(INTER_FUNCTIONSIG);
 ResultType setClass(INTER_FUNCTIONSIG);

VirtulMathCore/include/statement.h

@@ -50,7 +50,7 @@ struct Statement{
                 null_value = 6,
             } type;
             struct LinkValue *value;
-            char *str;
+            wchar_t *str;
         } base_value;
         struct base_var{
             char *name;
@@ -196,7 +196,7 @@ struct Statement{
         struct {
             struct Statement *command;
             struct Statement *as;
-            char *label;
+            wchar_t *label;
         } label_;
         struct {
             struct Statement *times;
@@ -268,7 +268,7 @@ void connectStatement(Statement *base, Statement *new);
 Statement *makeOperationBaseStatement(enum OperationType type, fline line, char *file);
 Statement *makeOperationStatement(enum OperationType type, Statement *left, Statement *right);
 Statement *makeBaseLinkValueStatement(LinkValue *value, fline line, char *file);
-Statement *makeBaseStrValueStatement(char *value, enum BaseValueType type, 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 *makeBaseSVarStatement(Statement *name, Statement *times);
@@ -296,7 +296,7 @@ Statement *makeIncludeStatement(Statement *file, fline line, char *file_dir);
 Statement *makeImportStatement(Statement *file, Statement *as, bool is_lock);
 Statement *makeFromImportStatement(Statement *file, Parameter *as, Parameter *pt, bool is_lock);
 Statement *makeDefaultVarStatement(Parameter *var, fline line, char *file_dir, enum DefaultType type);
-Statement *makeLabelStatement(Statement *var, Statement *command, char *label, fline line, char *file_dir);
+Statement *makeLabelStatement(Statement *var, Statement *command, wchar_t *label, fline line, char *file_dir);
 Statement *makeGotoStatement(Statement *return_, Statement *times, Statement *label, fline line, char *file_dir);
 Statement *makeDelStatement(Statement *var, fline line, char *file_dir);
 Token *setOperationFromToken(Statement **st_ad, Token *left, Token *right, enum OperationType type, bool is_right);

VirtulMathCore/include/syntax.h

@@ -1,16 +1,16 @@
 #ifndef VIRTUALMATH_SYNTAX_H
 #define VIRTUALMATH_SYNTAX_H
 
-#define strMatherMacro(n, word) strMather(p, mathers->mathers[n], word) /*这个宏只能用于getMatherStatus*/
+#define strMatherMacro(n, word) strMather(p, mathers->mathers[n], (wchar_t *)L##word) /*这个宏只能用于getMatherStatus*/
 #define charMatherMacro(n, word) charMather(p, mathers->mathers[n], word) /*这个宏只能用于getMatherStatus*/
 
-void numberMather(int p, LexMather *mather);
-void varMather(int p, LexMather *mather);
-void stringMather(int p, LexMather *mather);
-void strMather(int p, LexMather *mather, const char *dest_p);
-void charMather(int p, LexMather *mather, int dest_p);
-void aCharMather(int p, LexMather *mather, int dest_p);
-void spaceMather(int p, LexMather *mather);
-void commentMather(int p, LexMather *mather);
-void backslashMather(int p, LexMather *mather);
+void numberMather(wint_t p, LexMather *mather);
+void varMather(wint_t p, LexMather *mather);
+void stringMather(wint_t p, LexMather *mather);
+void strMather(wint_t p, LexMather *mather, const wchar_t *dest_p);
+void charMather(wint_t p, LexMather *mather, wint_t dest_p);
+void aCharMather(wint_t p, LexMather *mather, wint_t dest_p);
+void spaceMather(wint_t p, LexMather *mather);
+void commentMather(wint_t p, LexMather *mather);
+void backslashMather(wint_t p, LexMather *mather);
 #endif //VIRTUALMATH_SYNTAX_H

VirtulMathCore/include/token.h

@@ -98,14 +98,14 @@
 #define MATHER_MAX 84
 
 // 从-6开始是为了避开status的特殊值，尽管这并没有什么影响
-#define COMMAND -6
-#define OPERATION -7
-#define POLYNOMIAL -8
-#define FACTOR -9
-#define BASEVALUE -10
-#define ASSIGNMENT -11
-#define CODE -12
-#define FUNCTION -13
+#define COMMAND (-6)
+#define OPERATION (-7)
+#define POLYNOMIAL (-8)
+#define FACTOR (-9)
+#define BASEVALUE (-10)
+#define ASSIGNMENT (-11)
+#define CODE (-12)
+#define FUNCTION (-13)
 #define CALLBACK -14
 #define IF_BRANCH -15
 #define WHILE_BRANCH -16
@@ -134,8 +134,8 @@ struct Token{
     int token_type;  // 记录token的类型，大于0的数字均为lex匹配器所匹配，小于0的为syntax解析器所匹配
     fline line;
     struct TokenData{
-        char *str;
-        char *second_str;  // 针对123.4j这种形式设定的，其中second_str存储j
+        wchar_t *str;
+        wchar_t *second_str;  // 针对123.4j这种形式设定的，其中second_str存储j
         struct Statement *st;
     } data;
     struct Token *next;
@@ -163,7 +163,7 @@ void freeTokenMessage(TokenMessage *tm, bool self, bool free_st);
 
 Token *makeToken(long int line);
 long freeToken(Token *tk, bool free_st);
-Token *makeLexToken(int type, char *str, char *second_str, long int line);
+Token *makeLexToken(int type, wchar_t *str, wchar_t *second_str, long int line);
 Token *makeStatementToken(int type, struct Statement *st);
 
 extern Token *getToken(LexFile *file, LexMathers *mathers);

VirtulMathCore/include/value.h

@@ -55,7 +55,7 @@ struct Number {
 };
 
 struct String {
-    char *str;
+    wchar_t *str;
 };
 
 struct Function{
@@ -143,7 +143,7 @@ struct Result {
         goto_return=9,
         yield_return=10,
     } type;
-    char *label;
+    wchar_t *label;
     struct LinkValue *value;
     struct Error *error;
     vnum times;
@@ -201,7 +201,7 @@ Value *useNoneValue(Inter *inter, Result *result);
 Value *makeBoolValue(bool bool_num, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 Value *makePassValue(fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 Value *makeNumberValue(vnum num, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
-Value *makeStringValue(char *str, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+Value *makeStringValue(wchar_t *str, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 Value *makeVMFunctionValue(struct Statement *st, struct Parameter *pt, INTER_FUNCTIONSIG_NOT_ST);
 Value *makeCFunctionValue(OfficialFunction of, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 LinkValue *makeCFunctionFromOf(OfficialFunction of, LinkValue *func, OfficialFunction function_new, OfficialFunction function_init, LinkValue *belong, VarList *var_list, Inter *inter);

VirtulMathCore/memory/mem.c

@@ -25,13 +25,21 @@ void *memRealloc(void *old, size_t size){
     return tmp;
 }
 
-char *memStrcpy(const char *const str){
+char *memStrcpy(const char *str){
     char *tmp = memString(memStrlen(str));
     if (str != NULL)
         strcpy(tmp, str);
     return tmp;
 }
 
+wchar_t *memWidecpy(const wchar_t *str){
+    wchar_t *tmp = memWide(memWidelen(str));
+    if (str != NULL)
+        wcscpy(tmp, str);
+    return tmp;
+}
+
+// TODO-szh 检查useage
 char *memStrCharcpy(char *str, size_t nsize, bool free_old, bool write, ...) {  // 复制str到新的空间，nszie是要扩展的大小。该函数支持让str=NULL，则变为单纯的memString
     char *tmp = memString(memStrlen(str) + nsize);
     size_t base_len = memStrlen(str);
@@ -49,6 +57,23 @@ char *memStrCharcpy(char *str, size_t nsize, bool free_old, bool write, ...) {
     return tmp;
 }
 
+wchar_t *memWideCharcpy(wchar_t *str, size_t nsize, bool free_old, bool write, ...) {  // 复制str到新的空间，nszie是要扩展的大小。该函数支持让str=NULL，则变为单纯的memString
+    size_t base_len = memWidelen(str);
+    wchar_t *tmp = memWide(base_len + nsize);
+    if (base_len != 0)
+        wcscpy(tmp, str);
+    if (write){
+        va_list argp;
+        va_start(argp, write);
+        for (int i = 0; i < nsize; i++)
+            tmp[base_len + i] = (wchar_t)va_arg(argp, int);
+        va_end(argp);
+    }
+    if (free_old)
+        memFree(str);
+    return tmp;
+}
+
 char *memStrcatIter(char *base, bool free_base, ...) {
     va_list ap;
     va_start(ap, free_base);
@@ -81,6 +106,27 @@ char *memStrcat(char *first, char *second, bool free_first, bool free_last) {
     return new;
 }
 
+wchar_t *memWidecat(wchar_t *first, wchar_t *second, bool free_first, bool free_last) {
+    if (first == NULL && second == NULL)
+        return NULL;
+    else if (first == NULL){
+        first = second;
+        second = NULL;
+        free_first = free_last;
+        free_last = false;
+    }
+
+    wchar_t *new = memWideCharcpy(first, memWidelen(second), false, false);
+    if (second != NULL)
+        wcscat(new, second);
+
+    if (free_first)
+        memFree(first);
+    if (free_last)
+        memFree(second);
+    return new;
+}
+
 char *memStrcpySelf(char *str, long times){
     bool need_free = false;
     char *new_str = NULL;
@@ -96,10 +142,51 @@ char *memStrcpySelf(char *str, long times){
     return new_str;
 }
 
-char *memStrrev(const char *const str){
+wchar_t *memWidecpySelf(wchar_t *str, long times){
+    bool need_free = false;
+    wchar_t *new_str = NULL;
+    if (times < 0){
+        str = memWiderev(str);
+        times = -times;
+        need_free = true;
+    }
+    for (long i=0; i < times; i++)
+        new_str = memWidecat(new_str, str, true, false);
+    if (need_free)
+        memFree(str);
+    return new_str;
+}
+
+wchar_t *memWiderev(wchar_t *str){
+    size_t len_str = memWidelen(str);
+    wchar_t *new_str = memWide(len_str);
+    for (int i = 0;i < len_str;i++)
+        new_str[i] = str[len_str - i - 1];
+    return new_str;
+}
+
+char *memStrrev(const char * str){
     size_t len_str = memStrlen(str);
     char *new_str = memString(len_str);
     for (int i = 0;i < len_str;i++)
         new_str[i] = str[len_str - i - 1];
     return new_str;
 }
+
+wchar_t *strToWcs(char *str, bool free_old) {
+    size_t len = memStrlen(str);
+    wchar_t *tmp = memWide(len);
+    mbstowcs(tmp, str, len);
+    if (free_old)
+        memFree(str);
+    return tmp;
+}
+
+char *wcsToStr(wchar_t *wcs, bool free_old) {
+    size_t len = memWidelen(wcs);
+    char *tmp = memString(len);
+    wcstombs(tmp, wcs, len);
+    if (free_old)
+        memFree(wcs);
+    return tmp;
+}

VirtulMathCore/ofunc/src/dict.c

@@ -17,7 +17,6 @@ ResultType dict_new(OFFICAL_FUNCTIONSIG){
         return error_return;
     }
 
-
     value = make_new(inter, belong, ap[0].value);
     hash = pushVarList(var_list, inter);
     value->value->type = dict;
@@ -174,7 +173,7 @@ ResultType dict_iter(OFFICAL_FUNCTIONSIG){
 ResultType dictRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
-    char *repo = NULL;
+    wchar_t *repo = NULL;
     Value *value = NULL;
     LinkValue *again = NULL;
     setResultCore(result);
@@ -194,37 +193,37 @@ ResultType dictRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
         if (!CHECK_RESULT(result))
             return result->type;
         if (again_) {
-            makeStringValue("{...}", 0, "dict.repo", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+            makeStringValue(L"{...}", 0, "dict.repo", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             return result->type;
         }
     }
 
     setBoolAttrible(true, is_repo ? "repo_again" : "str_again", 0, "dict.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
-    repo = memStrcpy("{");
+    repo = memWidecpy((const wchar_t *) 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++) {
-            char *name_tmp;
-            char *value_tmp;
+            wchar_t *name_tmp;
+            wchar_t *value_tmp;
             if (count > 0)
-                repo = memStrcat(repo, ", ", true, false);
+                repo = memWidecat(repo, L", ", true, false);
 
             freeResult(result);
             name_tmp = getRepoStr(var->name_, is_repo, 0, "dict", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             if (!CHECK_RESULT(result))
                 goto return_;
-            repo = memStrcat(repo, name_tmp, true, false);
-            repo = memStrcat(repo, ": ", true, false);
+            repo = memWidecat(repo, name_tmp, true, false);
+            repo = memWidecat(repo, L": ", true, false);
 
             freeResult(result);
             value_tmp = getRepoStr(var->value, is_repo, 0, "dict", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             if (!CHECK_RESULT(result))
                 goto return_;
-            repo = memStrcat(repo, value_tmp, true, false);
+            repo = memWidecat(repo, value_tmp, true, false);
         }
     }
 
     freeResult(result);
-    repo = memStrcat(repo, "}", true, false);
+    repo = memWidecat(repo, L"}", true, false);
     makeStringValue(repo, 0, "dict.repo", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
 
     return_:

VirtulMathCore/ofunc/src/io.c

@@ -13,16 +13,16 @@ ResultType vm_print(OFFICAL_FUNCTIONSIG){
     arg = ap[0].arg;
     for (int i=0; i < ap[0].c_count; arg = arg->next,i++){
         freeResult(result);
-        char *tmp = getRepoStr(arg->data.value, true, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+        wchar_t *tmp = getRepoStr(arg->data.value, true, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         if (!CHECK_RESULT(result))
             return result->type;
         if (i != 0)
             fprintf(inter->data.inter_stdout, " ");
-        fprintf(inter->data.inter_stdout, "%s", tmp);
+        fprintf(inter->data.inter_stdout, "%ls", tmp);
     }
 
     if (ap[1].value != NULL && ap[1].value->value->type == string)
-        fprintf(inter->data.inter_stdout, "%s", ap[1].value->value->data.str.str);
+        fprintf(inter->data.inter_stdout, "%ls", ap[1].value->value->data.str.str);
     else
         fprintf(inter->data.inter_stdout, "\n");
 
@@ -34,8 +34,8 @@ ResultType vm_input(OFFICAL_FUNCTIONSIG){
     setResultCore(result);
     ArgumentParser ap[] = {{.type=name_value, .name="message", .must=0, .value=NULL},
                            {.must=-1}};
-    char *str = memStrcpy("\0");
-    int ch;
+    wchar_t *str = memWidecpy((wchar_t *) L"\0");
+    wint_t ch;
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         return result->type;
@@ -44,8 +44,8 @@ ResultType vm_input(OFFICAL_FUNCTIONSIG){
     if (ap[0].value != NULL)
         printValue(ap[0].value->value, inter->data.inter_stdout, false, true);
 
-    while ((ch = fgetc(inter->data.inter_stdin)) != '\n' && ch != EOF)
-        str = memStrCharcpy(str, 1, true, true, ch);
+    while ((ch = fgetwc(inter->data.inter_stdin)) != '\n' && ch != WEOF)
+        str = memWideCharcpy(str, 1, true, true, ch);
 
     makeStringValue(str, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     memFree(str);

VirtulMathCore/ofunc/src/list.c

@@ -352,7 +352,7 @@ ResultType list_iter(OFFICAL_FUNCTIONSIG){
 ResultType listRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
-    char *repo = NULL;
+    wchar_t *repo = NULL;
     Value *value = NULL;
     LinkValue *again = NULL;
     enum ListType lt;
@@ -374,30 +374,30 @@ ResultType listRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
         if (!CHECK_RESULT(result))
             return result->type;
         if (again_) {
-            makeStringValue(lt == value_list ? "[...]" : "(...)", 0, "list.repo", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+            makeStringValue((lt == value_list ? L"[...]" : L"(...)"), 0, "list.repo", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             return result->type;
         }
     }
 
     setBoolAttrible(true, is_repo ? "repo_again" : "str_again", 0, "list.repo", ap[0].value, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (lt == value_list)
-        repo = memStrcpy("[");
+        repo = memWidecpy(L"[");
     else
-        repo = memStrcpy("(");
+        repo = memWidecpy(L"(");
     for (int i=0;i < value->data.list.size;i++){
-        char *tmp;
+        wchar_t *tmp;
         freeResult(result);
         if (i > 0)
-            repo = memStrcat(repo, ", ", true, false);
+            repo = memWidecat(repo, L", ", true, false);
         tmp = getRepoStr(value->data.list.list[i], is_repo, 0, "sys", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         if (!CHECK_RESULT(result))
             goto return_;
-        repo = memStrcat(repo, tmp, true, false);
+        repo = memWidecat(repo, tmp, true, false);
     }
     if (lt == value_list)
-        repo = memStrcat(repo, "]", true, false);
+        repo = memWidecat(repo, L"]", true, false);
     else
-        repo = memStrcat(repo, ")", true, false);
+        repo = memWidecat(repo, L")", true, false);
 
     freeResult(result);
     makeStringValue(repo, 0, "list.repo", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));

VirtulMathCore/ofunc/src/num.c

@@ -45,7 +45,7 @@ ResultType num_init(OFFICAL_FUNCTIONSIG){
             base->value->data.num.num = ap[1].value->value->data.num.num;
             break;
         case string:
-            base->value->data.num.num = strtoll(ap[1].value->value->data.str.str, NULL, 10);
+            base->value->data.num.num = wcstoll(ap[1].value->value->data.str.str, NULL, 10);
             break;
         case bool_:
             base->value->data.num.num = ap[1].value->value->data.bool_.bool_;

VirtulMathCore/ofunc/src/object.c

@@ -27,9 +27,9 @@ ResultType object_new(OFFICAL_FUNCTIONSIG){
 ResultType objectRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
-    char *repo;
-    char *name;
-    char *type;
+    wchar_t *repo;
+    wchar_t *name;
+    wchar_t *type;
     LinkValue *name_value;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -46,19 +46,19 @@ ResultType objectRepoStrCore(OFFICAL_FUNCTIONSIG, bool is_repo){
             return result->type;
         freeResult(result);
     } else
-        name = "unknown";
+        name = L"unknown";
 
     if (ap[0].value->value->type == none) {
-        repo = memStrcpy("null");
+        repo = memWidecpy(L"null");
     } else {
         size_t len;
         if (ap[0].value->value->type == class)
-            type = "class";
+            type = L"class";
         else
-            type = "object";
-        len = memStrlen(name) + 30;
+            type = L"object";
+        len = memWidelen(name) + 30;
         repo = memCalloc(len, sizeof(char ));
-        snprintf(repo, len, "(%s: %s on %p)", type, name, ap[0].value->value);
+        swprintf(repo, len, (const wchar_t *) L"(%ls: %ls on %p)", type, name, ap[0].value->value);
     }
 
     makeStringValue(repo, 0, "object.repo", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));

VirtulMathCore/ofunc/src/str.c

@@ -13,7 +13,7 @@ ResultType str_new(OFFICAL_FUNCTIONSIG){
     setResultCore(result);
     value = make_new(inter, belong, ap[0].value);
     value->value->type = string;
-    value->value->data.str.str = memStrcpy("");
+    value->value->data.str.str = memWidecpy(L"");
     switch (init_new(value, arg, "str.new", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong))) {
         case 1:
             freeResult(result);
@@ -30,7 +30,7 @@ ResultType str_init(OFFICAL_FUNCTIONSIG){
                            {.type=only_value, .must=0, .long_arg=false},
                            {.must=-1}};
     LinkValue *base;
-    char *str = NULL;
+    wchar_t *str = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
@@ -43,7 +43,7 @@ ResultType str_init(OFFICAL_FUNCTIONSIG){
         if (!CHECK_RESULT(result))
             return result->type;
         memFree(base->value->data.str.str);
-        base->value->data.str.str = memStrcpy(str);
+        base->value->data.str.str = memWidecpy(str);
     }
     setResultBase(result, inter);
     return result->type;
@@ -69,7 +69,7 @@ ResultType str_slice(OFFICAL_FUNCTIONSIG){
         setResultError(E_TypeException, INSTANCE_ERROR(str), 0, "str", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         return error_return;
     }
-    size = memStrlen(ap[0].value->value->data.str.str);
+    size = memWidelen(ap[0].value->value->data.str.str);
 
     first = 0;
     second = size;
@@ -87,9 +87,9 @@ ResultType str_slice(OFFICAL_FUNCTIONSIG){
         return result->type;
 
     {
-        char *str = NULL;
+        wchar_t *str = NULL;
         for (vnum i = stride > 0 ? first : second; stride > 0 ? (i < second) : (i > first); i += stride)
-            str = memStrCharcpy(str, 1, true, true, ap[0].value->value->data.str.str[i]);
+            str = memWideCharcpy(str, 1, true, true, ap[0].value->value->data.str.str[i]);
         makeStringValue(str, 0, "str.slice", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         memFree(str);
     }
@@ -102,7 +102,7 @@ ResultType str_down(OFFICAL_FUNCTIONSIG){
                            {.must=-1}};
     vnum size;
     vnum index;
-    char element[2] = {};
+    wchar_t element[2] = {};
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
@@ -118,7 +118,7 @@ ResultType str_down(OFFICAL_FUNCTIONSIG){
         return error_return;
     }
 
-    size = memStrlen(ap[0].value->value->data.str.str);
+    size = memWidelen(ap[0].value->value->data.str.str);
     index = ap[1].value->value->data.num.num;
     if (!checkIndex(&index, &size, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong)))
         return result->type;
@@ -141,12 +141,12 @@ ResultType str_to_list(OFFICAL_FUNCTIONSIG){
         setResultError(E_TypeException, INSTANCE_ERROR(str), 0, "str", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         return error_return;
     }
-    size = memStrlen(ap[0].value->value->data.str.str);
+    size = memWidelen(ap[0].value->value->data.str.str);
 
     {
         Argument *new_list = NULL;
         for (vnum i = 0; i < size; i ++) {
-            char str[2] = {};
+            wchar_t str[2] = {};
             str[0] = ap[0].value->value->data.str.str[i];
             makeStringValue(str, 0, "str.to_list", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
             new_list = connectValueArgument(result->value, new_list);
@@ -220,7 +220,7 @@ LinkValue *makeStrFromOf(LinkValue *str, LinkValue *new, LinkValue *init, char *
     LinkValue *return_;
     return_ = callClassOf(str, inter, new, init);
     memFree(return_->value->data.str.str);
-    return_->value->data.str.str = memStrcpy(str_);
+    return_->value->data.str.str = strToWcs(str_, false);
     return return_;
 }
 

VirtulMathCore/ofunc/src/vobject.c

@@ -7,7 +7,7 @@ void vobject_add_base(LinkValue *belong, Result *result, struct Inter *inter, Va
     if (left->type == number && right->type == number)
         makeNumberValue(left->data.num.num + right->data.num.num, 0, "vobject.add", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     else if(left->type == string && right->type == string){
-        char *new_string = memStrcat(left->data.str.str, right->data.str.str, false, false);
+        wchar_t *new_string = memWidecat(left->data.str.str, right->data.str.str, false, false);
         makeStringValue(new_string, 0, "vobject.add", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         memFree(new_string);
     }
@@ -34,7 +34,7 @@ void vobject_mul_base(LinkValue *belong, Result *result, struct Inter *inter, Va
         goto mul_str;
     }
     else if(left->type == string && right->type == number) mul_str: {
-        char *new_string = memStrcpySelf(left->data.str.str, right->data.num.num);
+        wchar_t *new_string = memWidecpySelf(left->data.str.str, right->data.num.num);
         makeStringValue(new_string, 0, "vobject.mul", CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         memFree(new_string);
     }
@@ -107,7 +107,7 @@ ResultType vobject_bool(OFFICAL_FUNCTIONSIG){
             result_ = value->data.num.num != 0;
             break;
         case string:
-            result_ = memStrlen(value->data.str.str) > 0;
+            result_ = memWidelen(value->data.str.str) > 0;
             break;
         case bool_:
             result_ = value->data.bool_.bool_;
@@ -133,7 +133,7 @@ ResultType vobject_bool(OFFICAL_FUNCTIONSIG){
 ResultType vobject_repo(OFFICAL_FUNCTIONSIG){
     ArgumentParser ap[] = {{.type=only_value, .must=1, .long_arg=false},
                            {.must=-1}};
-    char *repo = NULL;
+    wchar_t *repo = NULL;
     Value *value = NULL;
     setResultCore(result);
     parserArgumentUnion(ap, arg, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -146,32 +146,32 @@ ResultType vobject_repo(OFFICAL_FUNCTIONSIG){
         case number: {
             char str[30] = {};
             snprintf(str, 30, "%lld", value->data.num.num);
-            repo = memStrcpy(str);
+            repo = strToWcs(str, false);
             break;
         }
         case string:
-            repo = memStrcpy(value->data.str.str);
+            repo = memWidecpy(value->data.str.str);
             break;
         case function: {
             char str[30] = {};
             snprintf(str, 30, "(function on %p)", value);
-            repo = memStrcpy(str);
+            repo = strToWcs(str, false);
             break;
         }
         case class: {
             char str[30] = {};
             snprintf(str, 30, "(class on %p)", value);
-            repo = memStrcpy(str);
+            repo = strToWcs(str, false);
             break;
         }
         case bool_:
             if (value->data.bool_.bool_)
-                repo = memStrcpy("true");
+                repo = strToWcs("true", false);
             else
-                repo = memStrcpy("false");
+                repo = strToWcs("false", false);
             break;
         case pass_:
-            repo = memStrcpy("...");
+            repo = strToWcs("...", false);
             break;
         default:
             setResultError(E_TypeException, CUL_ERROR(repo/str), 0, "vobject", true, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));

VirtulMathCore/parser/grammar.c

@@ -262,7 +262,7 @@ void parserLabel(PASERSSIGNATURE){
     Statement *command = NULL;
     Token *label_tk = NULL;
     int tmp;
-    char *label = NULL;
+    wchar_t *label = NULL;
     long int line = delToken(pm);
 
     if (!checkToken(pm, MATHER_COLON)){
@@ -273,7 +273,7 @@ void parserLabel(PASERSSIGNATURE){
         case MATHER_STRING:
         case MATHER_VAR:
             label_tk = popNewToken(pm->tm);
-            label = memStrcpy(label_tk->data.str);
+            label = memWidecpy(label_tk->data.str);
             freeToken(label_tk, false);
             break;
         default:
@@ -1376,9 +1376,10 @@ void parserBaseValue(PASERSSIGNATURE){
             if (*value_token->data.second_str == NUL)
                 st = tmp;
             else {
-                Statement *second_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line,
-                                                             pm->file);
+                char *ch = wcsToStr(value_token->data.second_str, false);
+                Statement *second_var = makeBaseVarStatement(ch, NULL, value_token->line, pm->file);
                 st = makeCallStatement(second_var, makeValueParameter(tmp));
+                memFree(ch);
             }
             break;
         }
@@ -1389,9 +1390,10 @@ void parserBaseValue(PASERSSIGNATURE){
             if (*value_token->data.second_str == NUL)
                 st = tmp;
             else {
-                Statement *sencod_var = makeBaseVarStatement(value_token->data.second_str, NULL, value_token->line,
-                                                             pm->file);
+                char *ch = wcsToStr(value_token->data.second_str, false);
+                Statement *sencod_var = makeBaseVarStatement(ch, NULL, value_token->line, pm->file);
                 st = makeCallStatement(sencod_var, makeValueParameter(tmp));
+                memFree(ch);
             }
             break;
         }
@@ -1429,9 +1431,12 @@ void parserBaseValue(PASERSSIGNATURE){
             st = makeLambdaStatement(lambda_st, pt);
             break;
         }
-        case MATHER_VAR:
-            st = makeBaseVarStatement(value_token->data.str, NULL, value_token->line, pm->file);
+        case MATHER_VAR: {
+            char *ch = wcsToStr(value_token->data.str, false);
+            st = makeBaseVarStatement(ch, NULL, value_token->line, pm->file);
+            memFree(ch);
             break;
+        }
         case MATHER_SVAR: {
             Statement *svar_st = NULL;
             if (!callChildStatement(CALLPASERSSIGNATURE, parserBaseValue, BASEVALUE, &svar_st, NULL)) {
@@ -1459,9 +1464,12 @@ void parserBaseValue(PASERSSIGNATURE){
             }
             if (MATHER_VAR == readBackToken(pm)) {
                 Token *var_token;
+                char *ch;
                 var_token = popNewToken(pm->tm);
-                st = makeBaseVarStatement(var_token->data.str, tmp_st, var_token->line, pm->file);
+                ch =  wcsToStr(var_token->data.str, false);
+                st = makeBaseVarStatement(ch, 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/parser/lexical.c

@@ -6,12 +6,12 @@
  * @param file
  * @return 返回一个字符，若为EOF则返回-1
  */
-int readChar(LexFile *file){
+wint_t readChar(LexFile *file){
     if (file->back.is_back)
         file->back.is_back = false;
     else
-        file->back.p = fgetc(file->file);
-    if (file->back.p == '\n')
+        file->back.p = fgetwc(file->file);
+    if (file->back.p == L'\n')
         file->line++;
     return file->back.p;
 }
@@ -22,14 +22,14 @@ int readChar(LexFile *file){
  */
 void backChar(LexFile *file){
     file->back.is_back = true;
-    if (file->back.p == '\n')
+    if (file->back.p == L'\n')
         file->line --;
 }
 
 void clearLexFile(LexFile *file) {
-    int ch;
+    wint_t ch;
     backChar(file);
-    while ((ch = readChar(file)) != '\n' && ch != EOF)
+    while ((ch = readChar(file)) != L'\n' && ch != WEOF)
         PASS;
 }
 
@@ -41,7 +41,7 @@ LexFile *makeLexFile(char *dir){
     else
         tmp->file = fopen(dir, "r");
     tmp->back.is_back = false;
-    tmp->back.p = EOF;
+    tmp->back.p = WEOF;
     tmp->line = 1;
     tmp->filter_data.enter = 0;
     return tmp;
@@ -65,7 +65,7 @@ void setupMather(LexMather *mather){
     mather->ascii = 0;
     mather->str = NULL;
     mather->second_str = NULL;
-    mather->string_type = '"';
+    mather->string_type = L'"';
     mather->status = LEXMATHER_START;
 }
 
@@ -140,12 +140,10 @@ int checkoutMather(LexMathers *mathers, int max) {
             end_second_count ++;
             end_second_index = i;
         }
-        else if(mathers->mathers[i]->status == LEXMATHER_MISTAKE){
+        else if(mathers->mathers[i]->status == LEXMATHER_MISTAKE)
             mistake_count ++;
-        }
-        else{
+        else
             return_1 = true;
-        }
     }
     if (return_1)
         goto return_;

VirtulMathCore/parser/syntax.c

@@ -12,19 +12,19 @@
  * @param p
  * @param mather
  */
-void numberMather(int p, LexMather *mather){
+void numberMather(wint_t p, LexMather *mather){
     if (mather->status == LEXMATHER_START || mather->status == LEXMATHER_ING_1 || mather->status == LEXMATHER_ING_2)
-        if (isdigit(p) || '.' == p && mather->status == LEXMATHER_ING_1){
-            mather->str = memStrCharcpy(mather->str, 1, true, true, p);
+        if (iswdigit(p) || L'.' == p && mather->status == LEXMATHER_ING_1){
+            mather->str = memWideCharcpy(mather->str, 1, true, true, p);
             mather->len += 1;
-            if ('.' == p)
+            if (L'.' == p)
                 mather->status = LEXMATHER_ING_2;
             else if (mather->status == LEXMATHER_START)
                 mather->status = LEXMATHER_ING_1;
         }
         else if(mather->status == LEXMATHER_ING_1 || mather->status == LEXMATHER_ING_2){
-            if (isalpha(p) ||'_' == p){
-                mather->second_str = memStrCharcpy(mather->second_str, 1, true, true, p);
+            if (iswalpha(p) || L'_' == p){
+                mather->second_str = memWideCharcpy(mather->second_str, 1, true, true, p);
                 mather->status = LEXMATHER_ING_3;
             }
             else
@@ -33,8 +33,8 @@ void numberMather(int p, LexMather *mather){
         else
             mather->status = LEXMATHER_MISTAKE;
     else if (mather->status == LEXMATHER_ING_3)
-        if (isalnum(p) ||'_' == p)
-            mather->second_str = memStrCharcpy(mather->second_str, 1, true, true, p);
+        if (iswalnum(p) || L'_' == p)
+            mather->second_str = memWideCharcpy(mather->second_str, 1, true, true, p);
         else
             mather->status = LEXMATHER_END_1;
     else
@@ -49,10 +49,10 @@ void numberMather(int p, LexMather *mather){
  * @param p
  * @param mather
  */
-void varMather(int p, LexMather *mather){
+void varMather(wint_t p, LexMather *mather){
     if (mather->status == LEXMATHER_START || mather->status == LEXMATHER_ING_1){
-        if (isalpha(p) ||'_' == p || isdigit(p) && mather->status == LEXMATHER_ING_1){
-            mather->str = memStrCharcpy(mather->str, 1, true, true, p);
+        if (iswalpha(p) || L'_' == p || iswdigit(p) && mather->status == LEXMATHER_ING_1){
+            mather->str = memWideCharcpy(mather->str, 1, true, true, p);
             mather->len ++;
             mather->status = LEXMATHER_ING_1;
         }
@@ -73,9 +73,9 @@ void varMather(int p, LexMather *mather){
  * @param p
  * @param mather
  */
-void stringMather(int p, LexMather *mather){
+void stringMather(wint_t p, LexMather *mather){
     if (mather->status == LEXMATHER_START)
-        if ('\"' == p || '\'' == p){
+        if (L'\"' == p || L'\'' == p){
             mather->status = LEXMATHER_ING_1;
             mather->string_type = p;
         }
@@ -84,80 +84,80 @@ void stringMather(int p, LexMather *mather){
     else if (mather->status == LEXMATHER_ING_1)
         if (mather->string_type == p)
             mather->status = LEXMATHER_ING_4;
-        else if ('\\' == p)
+        else if (L'\\' == p)
             mather->status = LEXMATHER_ING_5;
-        else if (EOF == p)
+        else if (WEOF == p)
             mather->status = LEXMATHER_MISTAKE;
         else{
-            mather->str = memStrCharcpy(mather->str, 1, true, true, p);
+            mather->str = memWideCharcpy(mather->str, 1, true, true, p);
             mather->len ++;
             mather->status = LEXMATHER_ING_1;
         }
     else if (mather->status == LEXMATHER_ING_3)
-        if (isalnum(p) ||'_' == p)
-            mather->second_str = memStrCharcpy(mather->second_str, 1, true, true, p);
+        if (iswalnum(p) || L'_' == p)
+            mather->second_str = memWideCharcpy(mather->second_str, 1, true, true, p);
         else
             mather->status = LEXMATHER_END_1;
     else if(mather->status == LEXMATHER_ING_4)
-        if (isalpha(p) ||'_' == p){
-            mather->second_str = memStrCharcpy(mather->second_str, 1, true, true, p);
+        if (iswalpha(p) || L'_' == p){
+            mather->second_str = memWideCharcpy(mather->second_str, 1, true, true, p);
             mather->status = LEXMATHER_ING_3;
         }
         else
             mather->status = LEXMATHER_END_1;
     else if (mather->status == LEXMATHER_ING_5){
-        char new = -1;
+        wchar_t new = (wchar_t)(-1);
         switch (p) {
-            case 'n':
-                new = '\n';
+            case L'n':
+                new = L'\n';
                 break;
-            case 't':
-                new = '\t';
+            case L't':
+                new = L'\t';
                 break;
-            case 'b':
-                new = '\b';
+            case L'b':
+                new = L'\b';
                 break;
-            case 'a':
-                new = '\a';
+            case L'a':
+                new = L'\a';
                 break;
-            case 'r':
-                new = '\r';
+            case L'r':
+                new = L'\r';
                 break;
-            case '\'':
-                new = '\'';
+            case L'\'':
+                new = L'\'';
                 break;
-            case '"':
-                new = '"';
+            case L'"':
+                new = L'"';
                 break;
-            case '\\':
-                new = '\\';
+            case L'\\':
+                new = L'\\';
                 break;
-            case '[':
+            case L'[':
                 mather->status = LEXMATHER_ING_6;
                 break;
             default :
-            case '0':
+            case L'0':
                 mather->status = LEXMATHER_MISTAKE;
                 break;
         }
-        if (new != -1) {
-            mather->str = memStrCharcpy(mather->str, 1, true, true, new);
+        if (new != (wchar_t)(-1)) {
+            mather->str = memWideCharcpy(mather->str, 1, true, true, new);
             mather->status = LEXMATHER_ING_1;
             mather->len ++;
         }
     }
     else if (mather->status == LEXMATHER_ING_6)
-        if (p == ']')
+        if (p == L']')
             if (mather->ascii <= 0)
                 mather->status = LEXMATHER_MISTAKE;
             else {
-                mather->str = memStrCharcpy(mather->str, 1, true, true, (char)mather->ascii);
+                mather->str = memWideCharcpy(mather->str, 1, true, true, (char)mather->ascii);
                 mather->status = LEXMATHER_ING_1;
                 mather->len ++;
             }
-        else if (isdigit(p)){
-            char num_[2] = {(char)p, 0};
-            int num = (int)strtol(num_, NULL, 10);
+        else if (iswdigit(p)){  // 手动输入ascii码
+            wchar_t num_[2] = {(wchar_t)p, 0};
+            int num = (int)wcstol(num_, NULL, 10);  // ascii不大于127, 使用int即可
             mather->ascii = (mather->ascii * 10) + num;
             if (mather->ascii > 127)
                 mather->status = LEXMATHER_MISTAKE;
@@ -173,14 +173,14 @@ void stringMather(int p, LexMather *mather){
  * @param mather
  * @param dest_p
  */
-void strMather(int p, LexMather *mather, const char *dest_p){
+void strMather(wint_t p, LexMather *mather, const wchar_t *dest_p){
     if (mather->status == LEXMATHER_START || mather->status == LEXMATHER_ING_1)
         if (p == dest_p[mather->len]){
-            mather->str = memStrCharcpy(mather->str, 1, true, true, p);
+            mather->str = memWideCharcpy(mather->str, 1, true, true, p);
             mather->len ++;
             mather->status = LEXMATHER_ING_1;
         }
-        else if(mather->status == LEXMATHER_ING_1 && mather->len == memStrlen((char *)dest_p))
+        else if(mather->status == LEXMATHER_ING_1 && mather->len == memWidelen(dest_p))
             mather->status = LEXMATHER_END_1;
         else
             mather->status = LEXMATHER_MISTAKE;
@@ -194,9 +194,9 @@ void strMather(int p, LexMather *mather, const char *dest_p){
  * @param mather
  * @param dest_p
  */
-void charMather(int p, LexMather *mather, int dest_p){
+void charMather(wint_t p, LexMather *mather, wint_t dest_p){
     if (p == dest_p && mather->status == LEXMATHER_START){
-        mather->str = memStrCharcpy(mather->str, 1, true, true, p);
+        mather->str = memWideCharcpy(mather->str, 1, true, true, p);
         mather->len ++;
         mather->status = LEXMATHER_ING_1;
     }
@@ -206,9 +206,9 @@ void charMather(int p, LexMather *mather, int dest_p){
         mather->status = LEXMATHER_MISTAKE;
 }
 
-void aCharMather(int p, LexMather *mather, int dest_p) {
+void aCharMather(wint_t p, LexMather *mather, wint_t dest_p) {
     if (p == dest_p && mather->status == LEXMATHER_START){
-        mather->str = memStrCharcpy(mather->str, 1, true, true, p);
+        mather->str = memWideCharcpy(mather->str, 1, true, true, p);
         mather->len ++;
         mather->status = LEXMATHER_END_1;
     }
@@ -221,10 +221,10 @@ void aCharMather(int p, LexMather *mather, int dest_p) {
  * @param p
  * @param mather
  */
-void spaceMather(int p, LexMather *mather){
+void spaceMather(wint_t p, LexMather *mather){
     if (mather->status == LEXMATHER_START || mather->status == LEXMATHER_ING_1)
-        if (isspace(p) && p != '\n'){
-            mather->str = memStrCharcpy(mather->str, 1, true, true, p);
+        if (iswspace(p) && L'\n' != p){
+            mather->str = memWideCharcpy(mather->str, 1, true, true, p);
             mather->len ++;
             mather->status = LEXMATHER_ING_1;
         }
@@ -236,16 +236,16 @@ void spaceMather(int p, LexMather *mather){
         mather->status = LEXMATHER_MISTAKE;
 }
 
-void backslashMather(int p, LexMather *mather){
+void backslashMather(wint_t p, LexMather *mather){
     if (mather->status == LEXMATHER_START)
-        if (p == '\\')
+        if (p == L'\\')
             mather->status = LEXMATHER_ING_1;
         else
             mather->status = LEXMATHER_MISTAKE;
     else if (mather->status == LEXMATHER_ING_1) {
-        if (p == EOF)
+        if (p == WEOF)
             mather->status = LEXMATHER_END_1;
-        else if (p == '\n')
+        else if (p == L'\n')
             mather->status = LEXMATHER_ING_2;
     }
     else if (mather->status == LEXMATHER_ING_2)
@@ -254,33 +254,33 @@ void backslashMather(int p, LexMather *mather){
         mather->status = LEXMATHER_MISTAKE;
 }
 
-void commentMather(int p, LexMather *mather){
+void commentMather(wint_t p, LexMather *mather){
     if (mather->status == LEXMATHER_START) {
-        if (p == '#')
+        if (p == L'#')
             mather->status = LEXMATHER_ING_1;
         else
             mather->status = LEXMATHER_MISTAKE;
     }
     else if (mather->status == LEXMATHER_ING_1) {  // 匹配到1个#的模式
-        if (p == '#')
+        if (p == L'#')
             mather->status = LEXMATHER_ING_3;
-        else if (p == '\n' || p == EOF)
+        else if (p == L'\n' || p == WEOF)
             mather->status = LEXMATHER_END_1;
         else
             mather->status = LEXMATHER_ING_2;
     }
     else if (mather->status == LEXMATHER_ING_2){  // 单#匹配模式
-        if (p == '\n' || p == EOF)
+        if (p == L'\n' || p == WEOF)
             mather->status = LEXMATHER_END_1;
     }
     else if (mather->status == LEXMATHER_ING_3) { // 双#匹配模式
-        if (p == '#')
+        if (p == L'#')
             mather->status = LEXMATHER_ING_4;
-        else if (p == EOF)
+        else if (p == WEOF)
             mather->status = LEXMATHER_END_1;
     }
     else if (mather->status == LEXMATHER_ING_4) {
-        if (p == '#')
+        if (p == L'#')
             mather->status = LEXMATHER_ING_5;
         else
             mather->status = LEXMATHER_ING_3;
@@ -299,7 +299,7 @@ void commentMather(int p, LexMather *mather){
  */
 int getMatherStatus(LexFile *file, LexMathers *mathers) {
     int status = -1;
-    int p;
+    wint_t p;
     setupMathers(mathers);
     while (status == -1){
         p = readChar(file);
@@ -316,7 +316,7 @@ int getMatherStatus(LexFile *file, LexMathers *mathers) {
         commentMather(p, mathers->mathers[MATHER_COMMENT]);
         aCharMather(p, mathers->mathers[MATHER_ENTER], '\n');
 
-        charMatherMacro(MATHER_EOF, EOF);
+        charMatherMacro(MATHER_EOF, WEOF);
         strMatherMacro(MATHER_IF, "if");  // 条件判断
         strMatherMacro(MATHER_ELIF, "elif");  // 条件循环
         strMatherMacro(MATHER_WHILE, "while");  // 条件循环

VirtulMathCore/parser/token.c

@@ -11,11 +11,11 @@ Token *makeToken(long int line) {
     return tmp;
 }
 
-Token *makeLexToken(int type, char *str, char *second_str, long int line) {
+Token *makeLexToken(int type, wchar_t *str, wchar_t *second_str, long int line) {
     Token *tmp = makeToken(line);
     tmp->token_type = type;
-    tmp->data.str = memStrcpy(str);
-    tmp->data.second_str = memStrcpy(second_str);
+    tmp->data.str = memWidecpy(str);
+    tmp->data.second_str = memWidecpy(second_str);
     return tmp;
 }
 

VirtulMathCore/src/__run.c

@@ -2,7 +2,7 @@
 
 
 ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
-    LinkValue *value;
+    wchar_t *wcs_name;
 
     *name = setStrVarName(st->u.base_var.name, false, inter);
     *times = 0;
@@ -20,7 +20,9 @@ ResultType getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     freeResult(result);
 
     not_times:
-    makeStringValue(st->u.base_var.name, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    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);
     return result->type;
 }
 
@@ -77,7 +79,7 @@ char *setNumVarName(vnum num, struct Inter *inter) {
 char *getNameFromValue(Value *value, struct Inter *inter) {
     switch (value->type){
         case string:
-            return setStrVarName(value->data.str.str, false, inter);
+            return setStrVarName(wcsToStr(value->data.str.str, false), true, inter);  // TODO-szh VAR使用宽字符
         case number:
             return setNumVarName(value->data.num.num, inter);
         case bool_:
@@ -298,11 +300,12 @@ void addStrVarCore(int setting, char *var_name, LinkValue *name_, LinkValue *val
 }
 
 void addStrVar(char *name, bool free_old, bool setting, LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
-    char *var_name = setStrVarName(name, free_old, inter);
     LinkValue *name_;
+    char *var_name = setStrVarName(name, free_old, inter);
+    wchar_t *wcs_name = strToWcs(name, false);
     setResultCore(result);
 
-    makeStringValue(name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    makeStringValue(wcs_name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         goto return_;
 
@@ -313,7 +316,9 @@ void addStrVar(char *name, bool free_old, bool setting, LinkValue *value, fline
     addStrVarCore(setting, var_name, name_, value, line, file, NULL, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
 
     gc_freeTmpLink(&name_->gc_status);
-    return_: memFree(var_name);
+    return_:
+    memFree(wcs_name);
+    memFree(var_name);
 }
 
 LinkValue *findAttributes(char *name, bool free_old, LinkValue *value, Inter *inter) {
@@ -325,10 +330,11 @@ LinkValue *findAttributes(char *name, bool free_old, LinkValue *value, Inter *in
 
 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);
     LinkValue *name_;
     setResultCore(result);
 
-    makeStringValue(name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+    makeStringValue(wcs_name, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
     if (!CHECK_RESULT(result))
         goto return_;
 
@@ -343,6 +349,7 @@ 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);
 }
 
@@ -420,7 +427,7 @@ bool checkBool(LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_S
     return false;
 }
 
-char *getRepoStr(LinkValue *value, bool is_repo, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST){
+wchar_t *getRepoStr(LinkValue *value, bool is_repo, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST){
     LinkValue *_repo_ = findAttributes(is_repo ? inter->data.object_repo : inter->data.object_str, false, value, inter);
     setResultCore(result);
     if (_repo_ != NULL){

VirtulMathCore/src/include/__run.h

@@ -32,7 +32,7 @@ void newObjectSetting(LinkValue *name, fline line, char *file, INTER_FUNCTIONSIG
 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);
 bool checkBool(LinkValue *value, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
-char *getRepoStr(LinkValue *value, bool is_repo, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
+wchar_t *getRepoStr(LinkValue *value, bool is_repo, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST);
 bool is_iterStop(LinkValue *value, Inter *inter);
 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);

VirtulMathCore/src/inter.c

@@ -358,14 +358,12 @@ void printHashTableGC(char *tag, Inter *inter, long *tmp_link) {
 
 void printToken(Token *tk) {
     if (tk->token_type >= 0) {
-        char *tmp = tk->data.str, *second_tmp = tk->data.second_str;
-        if (!strcmp(tmp, "\n"))
-            tmp = "\\n";
-        if (!strcmp(second_tmp, "\n"))
-            second_tmp = "\\n";
-        if (tmp[0] == EOF)
-            tmp = "(EOF)";
-        printf("<token str = ('%s','%s'), type = %d>", tmp, second_tmp, tk->token_type);
+        wchar_t *tmp = tk->data.str, *second_tmp = tk->data.second_str;
+        if (eqWide(tmp, (wchar_t *)L"\n"))
+            tmp = (wchar_t *) L"\\n";
+        if (eqWide(second_tmp, (wchar_t *)L"\n"))
+            second_tmp = (wchar_t *)L"\\n";
+        wprintf((wchar_t *)L"<token str = ('%ls','%ls'), type = %d>", tmp, second_tmp, tk->token_type);
     }
     else
         printf("<token statement, type = %d>", tk->token_type);

VirtulMathCore/src/run.c

@@ -319,9 +319,9 @@ bool blockSafeInterStatement(INTER_FUNCTIONSIG){
     return false;
 }
 
-Statement *checkLabel(Statement *base, char *label){
+Statement *checkLabel(Statement *base, wchar_t *label){
     for (PASS; base != NULL; base = base->next)
-        if (base->type == label_ && eqString(base->u.label_.label, label))
+        if (base->type == label_ && eqWide(base->u.label_.label, label))
             return base;
     return NULL;
 }

VirtulMathCore/src/runbranch.c

@@ -964,7 +964,7 @@ ResultType assertCode(INTER_FUNCTIONSIG){
 
 ResultType gotoLabel(INTER_FUNCTIONSIG){
     int times_int = 0;
-    char *label = NULL;
+    wchar_t *label = NULL;
     setResultCore(result);
 
     if (operationSafeInterStatement(CALL_INTER_FUNCTIONSIG(st->u.goto_.label, var_list, result, belong)))
@@ -973,7 +973,7 @@ ResultType gotoLabel(INTER_FUNCTIONSIG){
         setResultErrorSt(E_TypeException, ONLY_ACC(label name, string), true, st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
         return result->type;
     }
-    label = memStrcpy(result->value->value->data.str.str);
+    label = memWidecpy(result->value->value->data.str.str);
 
     freeResult(result);
     if (st->u.goto_.times == NULL)

VirtulMathCore/src/runfile.c

@@ -130,7 +130,7 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
         goto return_;
     }
 
-    file_dir = result->value->value->data.str.str;
+    file_dir = wcsToStr(result->value->value->data.str.str, false);
     freeResult(result);
     if (checkFileDir(&file_dir, CALL_INTER_FUNCTIONSIG(st, var_list, result, belong)) != 1)
         goto return_;
@@ -148,6 +148,7 @@ ResultType includeFile(INTER_FUNCTIONSIG) {
         setResultErrorSt(E_BaseException, NULL, false, st, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
 
     return_:
+    memFree(file_dir);
     freeStatement(new_st);
     freeParserMessage(pm, true);
     return result->type;
@@ -187,7 +188,7 @@ ResultType importFileCore(char **path, char **split, int *status, INTER_FUNCTION
         return error_return;
     }
 
-    *path = memStrcpy(result->value->value->data.str.str);
+    *path = wcsToStr(result->value->value->data.str.str, false);
     *split = splitDir(*path);  // 自动去除末尾路径分隔符
     freeResult(result);
     if ((*status = checkFileDir(path, CALL_INTER_FUNCTIONSIG(st, var_list, result, belong))) == 0)
@@ -307,9 +308,14 @@ ResultType fromImportFile(INTER_FUNCTIONSIG) {
         goto return_;
     imp_var = imp_value->value->object.var;
     if (is_new) {
+        wchar_t *wcs;
         LinkValue *string;
         freeResult(result);
-        makeStringValue(split_path, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, imp_value));
+
+        wcs = strToWcs(split_path, false);
+        makeStringValue(wcs, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, imp_value));
+        memFree(wcs);
+
         string = result->value;
         result->value = NULL;
         freeResult(result);

VirtulMathCore/src/runoperation.c

@@ -439,7 +439,7 @@ ResultType getBaseValue(INTER_FUNCTIONSIG) {
     else
         switch (st->u.base_value.type){
             case number_str:
-                makeNumberValue(strtol(st->u.base_value.str, NULL, 10), st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+                makeNumberValue(wcstoll(st->u.base_value.str, NULL, 10), st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
                 break;
             case bool_true:
                 makeBoolValue(true, st->line, st->code_file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));

VirtulMathCore/src/statement.c

@@ -74,12 +74,12 @@ Statement *makeBaseLinkValueStatement(LinkValue *value, fline line, char *file)
     return tmp;
 }
 
-Statement *makeBaseStrValueStatement(char *value, enum BaseValueType type, fline line, char *file){
+Statement *makeBaseStrValueStatement(wchar_t *value, enum BaseValueType type, fline line, char *file){
     Statement *tmp = makeStatement(line, file);
     tmp->type = base_value;
     tmp->u.base_value.type = type;
     tmp->u.base_value.value = NULL;
-    tmp->u.base_value.str = memStrcpy(value);
+    tmp->u.base_value.str = memWidecpy(value);  // TODO-szh 需要修改运行BaseValue的函数
     return tmp;
 }
 
@@ -326,12 +326,12 @@ Statement *makeDefaultVarStatement(Parameter *var, fline line, char *file_dir, e
     return tmp;
 }
 
-Statement *makeLabelStatement(Statement *var, Statement *command, char *label, fline line, char *file_dir) {
+Statement *makeLabelStatement(Statement *var, Statement *command, wchar_t *label, fline line, char *file_dir) {
     Statement *tmp = makeStatement(line, file_dir);
     tmp->type = label_;
     tmp->u.label_.as = var;
     tmp->u.label_.command = command;
-    tmp->u.label_.label = memStrcpy(label);
+    tmp->u.label_.label = memWidecpy(label);
     return tmp;
 }
 
@@ -528,7 +528,7 @@ Statement *copyStatementCore(Statement *st){
                 gc_addStatementLink(&new->u.base_value.value->gc_status);
             }
             else if (new->u.base_value.type == string_str || new->u.base_value.type == number_str)
-                new->u.base_value.str = memStrcpy(st->u.base_value.str);
+                new->u.base_value.str = memWidecpy(st->u.base_value.str);
             break;
         case operation:
             new->u.operation.OperationType = st->u.operation.OperationType;
@@ -653,7 +653,7 @@ Statement *copyStatementCore(Statement *st){
         case label_:
             new->u.label_.command = copyStatement(st->u.label_.command);
             new->u.label_.as = copyStatement(st->u.label_.as);
-            new->u.label_.label = memStrcpy(st->u.label_.label);
+            new->u.label_.label = memWidecpy(st->u.label_.label);
             break;
         case goto_:
             new->u.goto_.times = copyStatement(st->u.goto_.times);

VirtulMathCore/src/value.c

@@ -72,7 +72,7 @@ Value *makeNumberValue(vnum num, fline line, char *file, INTER_FUNCTIONSIG_NOT_S
     return tmp;
 }
 
-Value *makeStringValue(char *str, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
+Value *makeStringValue(wchar_t *str, fline line, char *file, INTER_FUNCTIONSIG_NOT_ST) {
     Value *tmp = NULL;
     setResultCore(result);
     callBackCore(inter->data.str, NULL, line, file, 0, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
@@ -80,7 +80,7 @@ Value *makeStringValue(char *str, fline line, char *file, INTER_FUNCTIONSIG_NOT_
         return NULL;
     tmp = result->value->value;
     memFree(tmp->data.str.str);
-    tmp->data.str.str = memStrcpy(str);
+    tmp->data.str.str = memWidecpy(str);
     return tmp;
 }
 
@@ -337,7 +337,7 @@ char *getErrorInfo(LinkValue *exc, int type, Inter *inter){
     char *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 memStrcpy(_info_->value->data.str.str);
+        return wcsToStr(_info_->value->data.str.str, false);  // TODO-szh var使用宽字符
     else
         return type == 1 ? memStrcpy("Error Type: Unknown") : memStrcpy("Error Message: Unknown");
 }
@@ -351,7 +351,9 @@ void callException(LinkValue *exc, char *message, fline line, char *file, INTER_
 
     if (_new_ != NULL){
         Argument *arg = NULL;
-        makeStringValue(message, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+        wchar_t *wcs_message = strToWcs(message, false);
+        makeStringValue(wcs_message, line, file, CALL_INTER_FUNCTIONSIG_NOT_ST(var_list, result, belong));
+        memFree(wcs_message);
         if (!CHECK_RESULT(result))
             goto return_;
         arg =  makeValueArgument(result->value);
@@ -613,7 +615,7 @@ void printValue(Value *value, FILE *debug, bool print_father, bool print_in) {
             fprintf(debug, "%lld", value->data.num.num);
             break;
         case string:
-            fprintf(debug, "%s", value->data.str.str);
+            fprintf(debug, "%ls", value->data.str.str);
             break;
         case function:
             if (print_father)

main.c

@@ -11,14 +11,14 @@ int main(int argc, char *argv[]) {
     }
     memVirtualMathUseJmp = true;
 
-    if (getArgs(argc, argv))
+    if (getArgs(argc, argv))  // 命令行参数设定
         return 2;
 
     initVirtualMath();
     inter = makeInter(args.out_file, args.error_file, args.in_file, NULL);
-    runCodeFile(inter, argv + optind);
+    runCodeFile(inter, argv + optind);  // 从文件中运行代码
     if (args.run_commandLine)
-        runCodeStdin(inter, HelloString);
+        runCodeStdin(inter, HelloString);  // 从stdin中运行代码
     freeInter(inter, true);
 
     return 0;