feat: 变量和字典记录key的真实LinkValue

Var增加name_成员记录该值
Argument增加name_value记录该值
getVarInfo通过返回值返回Var的真实值

include/parameter.h

@@ -29,6 +29,7 @@ struct Argument{
         struct LinkValue *value;
         struct Statement *name;  // 仅在name-value模式生效
         char *name_;
+        struct LinkValue *name_value;
     } data;
     struct Argument *next;
 };
@@ -37,26 +38,26 @@ typedef struct Parameter Parameter;
 typedef struct Argument Argument;
 
 Argument *makeArgument();
-Argument *makeOnlyValueArgument(LinkValue *value);
-Argument *makeNameValueArgument(LinkValue *value, struct Statement *name);
-Argument *makeCharNameArgument(LinkValue *value, char *name);
+Argument *makeValueArgument(LinkValue *value);
+Argument *makeStatementNameArgument(LinkValue *value, struct Statement *name);
+Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, char *name);
 Argument *connectArgument(Argument *new, Argument *base);
-Argument *connectOnlyValueArgument(LinkValue *value, Argument *base);
-Argument *connectNameValueArgument(LinkValue *value, struct Statement *name, Argument *base);
-Argument *connectCharNameArgument(LinkValue *value, char *name, 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);
 void freeArgument(Argument *at, bool free_st);
 
 Parameter *makeParameter();
 Parameter *copyParameter(Parameter *base);
-Parameter *makeOnlyValueParameter(struct Statement *st);
-Parameter *makeNameValueParameter(struct Statement *value, struct Statement *name);
-Parameter *makeOnlyArgsParameter(struct Statement *st);
-Parameter *makeNameArgsParameter(struct Statement *st);
+Parameter *makeValueParameter(struct Statement *st);
+Parameter *makeNameParameter(struct Statement *value, struct Statement *name);
+Parameter *makeArgsParameter(struct Statement *st);
+Parameter *makeKwrgsParameter(struct Statement *st);
 Parameter *connectParameter(Parameter *new, Parameter *base);
-Parameter *connectOnlyValueParameter(struct Statement *st, Parameter *base);
-Parameter *connectNameValueParameter(struct Statement *value, struct Statement *name, Parameter *base);
-Parameter *connectOnlyArgsParameter(struct Statement *st, Parameter *base);
-Parameter *connectNameArgsParameter(struct Statement *st, Parameter *base);
+Parameter *connectValueParameter(struct Statement *st, Parameter *base);
+Parameter *connectNameParameter(struct Statement *value, struct Statement *name, Parameter *base);
+Parameter *connectArgsParameter(struct Statement *st, Parameter *base);
+Parameter *connectKwargsParameter(struct Statement *st, Parameter *base);
 void freeParameter(Parameter *pt, bool free_st);
 Argument *listToArgument(LinkValue *list_value, INTER_FUNCTIONSIG_CORE);
 Argument *dictToArgument(LinkValue *dict_value, INTER_FUNCTIONSIG_CORE);

include/var.h

@@ -6,6 +6,7 @@
 struct Var{
     char *name;
     struct LinkValue *value;
+    struct LinkValue *name_;
     struct Var *next;
 };
 
@@ -25,7 +26,7 @@ typedef struct Var Var;
 typedef struct HashTable HashTable;
 typedef struct VarList VarList;
 
-Var *makeVar(char *name, LinkValue *value);
+Var *makeVar(char *name, LinkValue *value, LinkValue *name_);
 Var *freeVar(Var *var, bool self);
 
 HashTable *makeHashTable(Inter *inter, bool supervision);
@@ -37,8 +38,8 @@ VarList *freeVarList(VarList *vl, bool self);
 HASH_INDEX time33(char *key);
 LinkValue *findVar(char *name, VarList *var_list, bool del_var);
 LinkValue *findFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, bool del_var);
-void addVar(char *name, LinkValue *value, VarList *var_list);
-void addFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, LinkValue *value);
+void addVar(char *name, LinkValue *value, LinkValue *name_, VarList *var_list);
+void addFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, LinkValue *value, LinkValue *name_);
 
 VarList *pushVarList(VarList *base, Inter *inter);
 VarList *popVarList(VarList *base);

main.c

@@ -18,4 +18,5 @@ int main(int argc, char *argv[]) {
 /**
  * TODO-szh 面向对象
  * TODO-szh import和include语句
+ * TODO-szh 错误回溯
  */

parser/__grammar.c

@@ -324,24 +324,24 @@ bool parserParameter(ParserMessage *pm, Inter *inter, Parameter **pt, bool is_fo
         }
 
         if (pt_type == value_par)
-            new_pt = connectOnlyValueParameter(tmp->data.st, new_pt);
+            new_pt = connectValueParameter(tmp->data.st, new_pt);
         else if (pt_type == name_par){
             Statement *tmp_value;
             if (!callChildStatement(CALLPASERSSIGNATURE, parserPolynomial, POLYNOMIAL, &tmp_value, "Don't get a parameter value"))
                 goto error_;
-            new_pt = connectNameValueParameter(tmp_value, tmp->data.st, new_pt);
+            new_pt = connectNameParameter(tmp_value, tmp->data.st, new_pt);
             if (!checkToken_(pm, sep))
                 last_pt = true;
         }
         else if (pt_type == args_par){
-            new_pt = connectOnlyArgsParameter(tmp->data.st, new_pt);
+            new_pt = connectArgsParameter(tmp->data.st, new_pt);
             if (is_formal)
                 status = s_2;  // 是否规定*args只出现一次
             else
                 status = s_1;
         }
         else {
-            new_pt = connectNameArgsParameter(tmp->data.st, new_pt);
+            new_pt = connectKwargsParameter(tmp->data.st, new_pt);
             if (is_formal)
                 last_pt = true; // 是否规定**kwargs只出现一次
             else

parser/grammar.c

@@ -821,7 +821,7 @@ void parserBaseValue(PASERSSIGNATURE){
                 st = tmp_st;
             }
             else
-                st = makeTupleStatement(makeOnlyValueParameter(tmp_st), value_list);
+                st = makeTupleStatement(makeValueParameter(tmp_st), value_list);
         }
     }
     else if (MATHER_LP == value_token->token_type){

src/__run.c

@@ -5,7 +5,7 @@ Result getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     Result times_tmp;
 
     *name = setStrVarName(st->u.base_var.name, false, inter, var_list);
-
+    *times = 0;
     if (st->u.base_var.times == NULL){
         *times = 0;
         goto not_times;
@@ -15,18 +15,18 @@ Result getBaseVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     *times = (int)times_tmp.value->value->data.num.num; // TODO-szh 类型检查
 
     not_times:
-    setResult(&result, true, inter);
+    setResultOperation(&result, inter);
+    result.value->value = makeStringValue(st->u.base_var.name, inter);
     return result;
 }
 
 Result getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     Result result;
-    Result value;
     Result times_tmp;
 
-    if (operationSafeInterStatement(&value, CALL_INTER_FUNCTIONSIG(st->u.base_svar.name, var_list)))
-        return value;
-    *name = getNameFromValue(value.value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
+    if (operationSafeInterStatement(&result, CALL_INTER_FUNCTIONSIG(st->u.base_svar.name, var_list)))
+        return result;
+    *name = getNameFromValue(result.value->value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
 
     if (st->u.base_svar.times == NULL){
         *times = 0;
@@ -37,7 +37,7 @@ Result getBaseSVarInfo(char **name, int *times, INTER_FUNCTIONSIG){
     *times = (int)times_tmp.value->value->data.num.num; // TODO-szh 类型检查
 
     not_times:
-    setResult(&result, true, inter);
+    result.type = operation_return;
     return result;
 }
 

src/operation.c

@@ -150,7 +150,7 @@ Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE){
         Statement *tmp_st = makeStatement();
         tmp_st->type = base_value;
         tmp_st->u.base_value.value = value;
-        Parameter *pt = makeOnlyArgsParameter(tmp_st);
+        Parameter *pt = makeArgsParameter(tmp_st);
         Argument *call = getArgument(pt, &tmp_result, CALL_INTER_FUNCTIONSIG_CORE(var_list));
         if (!run_continue(tmp_result)) {
             freeArgument(call, false);
@@ -176,7 +176,7 @@ Result assCore(Statement *name, LinkValue *value, INTER_FUNCTIONSIG_CORE){
             memFree(str_name);
             return tmp;
         }
-        addFromVarList(str_name, var_list, int_times, value);
+        addFromVarList(str_name, var_list, int_times, value, tmp.value);
         memFree(str_name);
         result.value = value;
     }

src/parameter.c

@@ -17,13 +17,13 @@ Argument *makeArgument(){
     return tmp;
 }
 
-Argument *makeOnlyValueArgument(LinkValue *value){
+Argument *makeValueArgument(LinkValue *value){
     Argument *tmp = makeArgument();
     tmp->data.value = value;
     return tmp;
 }
 
-Argument *makeNameValueArgument(LinkValue *value, Statement *name){
+Argument *makeStatementNameArgument(LinkValue *value, Statement *name){
     Argument *tmp = makeArgument();
     tmp->type = name_arg;
     tmp->data.value = value;
@@ -31,7 +31,7 @@ Argument *makeNameValueArgument(LinkValue *value, Statement *name){
     return tmp;
 }
 
-Argument *makeCharNameArgument(LinkValue *value, char *name){
+Argument *makeCharNameArgument(LinkValue *value, LinkValue *name_value, char *name) {
     Argument *tmp = makeArgument();
     tmp->type = name_arg;
     tmp->name_type = name_char;
@@ -50,18 +50,18 @@ Argument *connectArgument(Argument *new, Argument *base){
     return tmp;
 }
 
-Argument *connectOnlyValueArgument(LinkValue *value, Argument *base){
-    Argument *new = makeOnlyValueArgument(value);
+Argument *connectValueArgument(LinkValue *value, Argument *base){
+    Argument *new = makeValueArgument(value);
     return connectArgument(new, base);
 }
 
-Argument *connectNameValueArgument(LinkValue *value, Statement *name, Argument *base){
-    Argument *new = makeNameValueArgument(value, name);
+Argument *connectStatementNameArgument(LinkValue *value, Statement *name, Argument *base){
+    Argument *new = makeStatementNameArgument(value, name);
     return connectArgument(new, base);
 }
 
-Argument *connectCharNameArgument(LinkValue *value, char *name, Argument *base){
-    Argument *new = makeCharNameArgument(value, name);
+Argument *connectCharNameArgument(LinkValue *value, LinkValue *name_value, char *name, Argument *base) {
+    Argument *new = makeCharNameArgument(value, name_value, name);
     return connectArgument(new, base);
 }
 
@@ -101,13 +101,13 @@ Parameter *copyParameter(Parameter *base){
     return base_tmp;
 }
 
-Parameter *makeOnlyValueParameter(Statement *st){
+Parameter *makeValueParameter(Statement *st){
     Parameter *tmp = makeParameter();
     tmp->data.value = st;
     return tmp;
 }
 
-Parameter *makeNameValueParameter(Statement *value, Statement *name){
+Parameter *makeNameParameter(Statement *value, Statement *name){
     Parameter *tmp = makeParameter();
     tmp->type = name_par;
     tmp->data.value = value;
@@ -115,14 +115,14 @@ Parameter *makeNameValueParameter(Statement *value, Statement *name){
     return tmp;
 }
 
-Parameter *makeOnlyArgsParameter(Statement *st){
+Parameter *makeArgsParameter(Statement *st){
     Parameter *tmp = makeParameter();
     tmp->type = args_par;
     tmp->data.value = st;
     return tmp;
 }
 
-Parameter *makeNameArgsParameter(Statement *st){
+Parameter *makeKwrgsParameter(Statement *st){
     Parameter *tmp = makeParameter();
     tmp->type = kwargs_par;
     tmp->data.value = st;
@@ -139,23 +139,23 @@ Parameter *connectParameter(Parameter *new, Parameter *base){
     return tmp;
 }
 
-Parameter *connectOnlyValueParameter(Statement *st, Parameter *base){
-    Parameter *new = makeOnlyValueParameter(st);
+Parameter *connectValueParameter(Statement *st, Parameter *base){
+    Parameter *new = makeValueParameter(st);
     return connectParameter(new, base);
 }
 
-Parameter *connectNameValueParameter(Statement *value, Statement *name, Parameter *base){
-    Parameter *new = makeNameValueParameter(value, name);
+Parameter *connectNameParameter(Statement *value, Statement *name, Parameter *base){
+    Parameter *new = makeNameParameter(value, name);
     return connectParameter(new, base);
 }
 
-Parameter *connectOnlyArgsParameter(Statement *st, Parameter *base){
-    Parameter *new = makeOnlyArgsParameter(st);
+Parameter *connectArgsParameter(Statement *st, Parameter *base){
+    Parameter *new = makeArgsParameter(st);
     return connectParameter(new, base);
 }
 
-Parameter *connectNameArgsParameter(Statement *st, Parameter *base){
-    Parameter *new = makeNameArgsParameter(st);
+Parameter *connectKwargsParameter(Statement *st, Parameter *base){
+    Parameter *new = makeKwrgsParameter(st);
     return connectParameter(new, base);
 }
 
@@ -174,7 +174,7 @@ void freeParameter(Parameter *pt, bool free_st) {
 Argument *listToArgument(LinkValue *list_value, INTER_FUNCTIONSIG_CORE){
     Argument *at = NULL;
     for (int i=0;i<list_value->value->data.list.size;i++){
-        at = connectOnlyValueArgument(list_value->value->data.list.list[i], at);
+        at = connectValueArgument(list_value->value->data.list.list[i], at);
     }
     return at;
 }
@@ -184,7 +184,7 @@ Argument *dictToArgument(LinkValue *dict_value, INTER_FUNCTIONSIG_CORE){
     for (int i = 0; i < MAX_SIZE; i++) {
         Var *tmp = dict_value->value->data.dict.dict->hashtable[i];
         while (tmp != NULL) {
-            at = connectCharNameArgument(tmp->value, tmp->name, at);
+            at = connectCharNameArgument(tmp->value, tmp->name_, tmp->name, at);
             tmp = tmp->next;
         }
     }
@@ -240,7 +240,7 @@ Result argumentToVar(Argument **call_ad, struct Inter *inter, struct VarList *va
     while (call != NULL && call->type == name_arg){
         Result tmp_ass;
         if (call->name_type == name_char){
-            addFromVarList(call->data.name_, var_list, 0, call->data.value);
+            addFromVarList(call->data.name_, var_list, 0, call->data.value, call->data.name_value);
             goto next;
         }
         tmp_ass = assCore(call->data.name, call->data.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
@@ -292,7 +292,7 @@ Result parameterFromVar(Parameter **function_ad, VarList *function_var, struct I
             goto not_return;
         }
 
-        tmp = getBaseVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list));
+        tmp = getVarInfo(&str_name, &int_times, CALL_INTER_FUNCTIONSIG(name, var_list));
         if (!run_continue(tmp)) {
             memFree(str_name);
             return tmp;
@@ -377,9 +377,9 @@ Result iterParameter(Parameter *call, Argument **base_ad, INTER_FUNCTIONSIG_CORE
         }
 
         if (call->type == value_par)
-            base = connectOnlyValueArgument(tmp.value, base);
+            base = connectValueArgument(tmp.value, base);
         else if (call->type == name_par)
-            base = connectNameValueArgument(tmp.value, call->data.name, base);
+            base = connectStatementNameArgument(tmp.value, call->data.name, base);
         else if (call->type == args_par){
             Argument *tmp_at = listToArgument(tmp.value, CALL_INTER_FUNCTIONSIG_CORE(var_list));
             base = connectArgument(tmp_at, base);

src/value.c

@@ -178,18 +178,18 @@ void printValue(Value *value, FILE *debug){
             writeLog(debug, INFO, "function on <%p>", value);
             break;
         case list:
-            writeLog(debug, INFO, "list on <%p> size : %d [", value, (int)value->data.list.size);
+            writeLog(debug, INFO, "list on <%p> size : %d  [ ", value, (int)value->data.list.size);
             for (int i=0;i < value->data.list.size;i++){
                 if (i > 0)
                     writeLog(debug, INFO, ", ", NULL);
 
                 printLinkValue(value->data.list.list[i], "", "", debug);
             }
-            writeLog(debug, INFO, "]", NULL);
+            writeLog(debug, INFO, " ]", NULL);
             break;
         case dict: {
             bool print_comma = false;
-            writeLog(debug, INFO, "dict on <%p> size : %d {", value, (int) value->data.dict.size);
+            writeLog(debug, INFO, "dict on <%p> size : %d  { ", value, (int) value->data.dict.size);
             for (int i = 0; i < MAX_SIZE; i++) {
                 Var *tmp = value->data.dict.dict->hashtable[i];
                 while (tmp != NULL) {
@@ -197,13 +197,13 @@ void printValue(Value *value, FILE *debug){
                         writeLog(debug, INFO, ", ", NULL);
                     else
                         print_comma = true;
-
-                    writeLog(debug, INFO, "'%s' : ", tmp->name);
+                    printLinkValue(tmp->name_, "", "", debug);
+                    writeLog(debug, INFO, " ['%s'] : ", tmp->name);
                     printLinkValue(tmp->value, "", "", debug);
                     tmp = tmp->next;
                 }
             }
-            writeLog(debug, INFO, "}", NULL);
+            writeLog(debug, INFO, " }", NULL);
             break;
         }
         case none:

src/var.c

@@ -1,10 +1,11 @@
 #include "__virtualmath.h"
 
-Var *makeVar(char *name, LinkValue *value){
+Var *makeVar(char *name, LinkValue *value, LinkValue *name_) {
     Var *tmp;
     tmp = memCalloc(1, sizeof(Var));
     tmp->name = memStrcpy(name, 0, false, false);
     tmp->value = value;
+    tmp->name_ = name_;
     tmp->next = NULL;
     return tmp;
 }
@@ -104,11 +105,11 @@ HASH_INDEX time33(char *key){ // hash function
 }
 
 
-void addVar(char *name, LinkValue *value, VarList *var_list){
+void addVar(char *name, LinkValue *value, LinkValue *name_, VarList *var_list) {
     HASH_INDEX index = time33(name);
     Var *base = var_list->hashtable->hashtable[index];
     if (base == NULL){
-        var_list->hashtable->hashtable[index] = makeVar(name, value);
+        var_list->hashtable->hashtable[index] = makeVar(name, value, name_);
         goto return_;
     }
     while (true){
@@ -119,7 +120,7 @@ void addVar(char *name, LinkValue *value, VarList *var_list){
         base = base->next;
     }
     new_one:
-    base->next = makeVar(name, value);
+    base->next = makeVar(name, value, name_);
     goto return_;
 
     change:
@@ -172,11 +173,11 @@ LinkValue *findFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, boo
     return tmp;
 }
 
-void addFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, LinkValue *value){
+void addFromVarList(char *name, VarList *var_list, NUMBER_TYPE times, LinkValue *value, LinkValue *name_) {
     for (NUMBER_TYPE i=0; i < times && var_list->next != NULL; i++){
         var_list = var_list->next;
     }
-    addVar(name, value, var_list);
+    addVar(name, value, name_, var_list);
 }
 
 VarList *pushVarList(VarList *base, Inter *inter){