引入 ImplementationDefinedScope

src/chsrc-main.c

@@ -317,31 +317,37 @@ cli_print_target_features (Target_t *target, const char *input_target_name)
       else if (i == 1)
         {
           scope_name = CHINESE ? " 用户级换源" : " user scope";
-          scope_msg = xy_strcat (3, scope_name, " | chsrc set -scope=user ", input_target_name);
+          scope_msg = xy_strcat (3, scope_name, " | chsrc set -scope=user    ", input_target_name);
         }
       else if (i == 2)
         {
           scope_name = CHINESE ? " 系统级换源" : " system scope";
-          scope_msg = xy_strcat (3, scope_name, " | chsrc set -scope=system ", input_target_name);
+          scope_msg = xy_strcat (3, scope_name, " | chsrc set -scope=system  ", input_target_name);
         }
       else
         {
           xy_unreached();
         }
 
+      char *msg = NULL;
       switch (cap)
         {
         case ScopeCap_Unknown:
-          printf (" %s%s (%s)\n", bdred(NoMark), purple(scope_msg), "是否支持该作用域尚不了解，欢迎贡献");
+          msg = xy_strcat (6, " ", bdred(NoMark), scope_msg, " (", "是否支持该作用域尚不了解，欢迎贡献", ")");
+          puts (msg);
           break;
         case ScopeCap_Unable:
-          printf (" %s%s (%s)\n", bdred(NoMark), purple(scope_msg), "不支持");
+          msg = xy_strcat (6, " ", bdred(NoMark), scope_msg, " (", "不支持", ")");
+          puts (msg);
           break;
         case ScopeCap_Able_But_Not_Implemented:
-          printf (" %s%s (%s)\n", bdyellow(HalfYesMark), purple(scope_msg), "支持但未实现");
+          msg = xy_strcat (6, " ", bdyellow(HalfYesMark), scope_msg, " (", "支持但未实现", ")");
+          puts (msg);
           break;
         case ScopeCap_Able_And_Implemented:
-          printf (" %s%s (%s)\n", bdgreen(YesMark), purple(scope_msg), "支持且已实现");
+          msg = xy_strcat (3, " ", bdgreen(YesMark),
+            purple (xy_strcat (4, scope_msg, " (", "支持且已实现", ")")));
+          puts (msg);
           break;
         default:
           xy_unreached();
@@ -360,11 +366,15 @@ cli_print_target_features (Target_t *target, const char *input_target_name)
       case SystemScope:
         default_scope_name = CHINESE ? "系统级" : "System Scope";
         break;
+      case ImplementationDefinedScope:
+        default_scope_name = CHINESE ? "由实现定义" : "Implementation Defined Scope";
+        break;
       default:
         xy_unreached();
       }
-    print (bdblue (" = "));
-    printf ("默认作用域 | chsrc set -scope=default %s (= %s)\n", input_target_name, default_scope_name);
+    char *msg = xy_strcat (3, bdblue (" = "),
+      purple (xy_strcat (5, "默认作用域 | chsrc set -scope=default ", input_target_name, " (= ", default_scope_name ,")")));
+    puts (msg);
     br();
   }
 
@@ -823,7 +833,7 @@ main (int argc, char const *argv[])
                 }
               else if (xy_streql_ic (scope, "default"))
                 {
-                  ProgMode.Scope = DefaultScope;
+                  ProgMode.Scope = ImplementationDefinedScope;
                 }
               else
                 {

src/framework/chef.c

@@ -332,6 +332,15 @@ chef_set_default_scope (Target_t *target, Scope_t scope)
     cap = target->scope_caps[ScopeCap_Slot_User];
   else if (scope == SystemScope)
     cap = target->scope_caps[ScopeCap_Slot_System];
+  else if (scope == ImplementationDefinedScope)
+    {
+      /* ImplementationDefinedScope 即由 chsrc 根据实际情况来决定，因此我们不对它检查 */
+      return;
+    }
+  else
+    {
+      chsrc_panic ("无效的 scope 参数");
+    }
 
   /* 防止 chef 们写错 */
   if (cap != ScopeCap_Able_And_Implemented)

src/framework/core.c

@@ -11,7 +11,7 @@
  *               | @Mikachu2333
  *               |
  * Created On    : <2023-08-29>
- * Last Modified : <2026-02-22>
+ * Last Modified : <2026-02-24>
  *
  * chsrc framework
  * ------------------------------------------------------------*/
@@ -57,7 +57,7 @@ ProgMode =
   .ResetMode   = false,
   .TargetGroupMode = false,
   .Ipv6Mode = false,
-  .Scope = DefaultScope,
+  .Scope = ImplementationDefinedScope,
   .EnglishMode = false,
   .DryRunMode = false,
   .NoColorMode = false
@@ -70,7 +70,8 @@ bool chsrc_in_standalone_mode() {return !ProgMode.TargetGroupMode;}
 void chsrc_set_target_group_mode(){ProgMode.TargetGroupMode = true;}
 
 bool chsrc_in_reset_mode(){return ProgMode.ResetMode;}
-bool chsrc_in_default_scope_mode(){return ProgMode.Scope == DefaultScope;}
+/* 默认换源作用域就是 ImplementationDefinedScope */
+bool chsrc_in_default_scope_mode(){return ProgMode.Scope == ImplementationDefinedScope;}
 bool chsrc_in_user_scope_mode(){return ProgMode.Scope == UserScope;}
 bool chsrc_in_project_scope_mode(){return ProgMode.Scope == ProjectScope;}
 bool chsrc_in_system_scope_mode(){return ProgMode.Scope == SystemScope;}

src/framework/struct.h

@@ -113,19 +113,23 @@ Source_t;
  * 但是后来，我们认为非 -local 时的行为（即默认时）比较模糊，所以我们现在清晰地把作用域指明出来，总共有3种类型的作用：
  * 分别是 ProjectScope、UserScope 和 SystemScope，分别对应项目级、用户级和系统级的换源配置
  *
- * 还有一个叫 DefaultScope 的作用域，它不是一种新类型，而只表示默认作用域，即根据实际情况最佳的作用域。
- * chsrc 将根据该 target 的实际情况来选择最合适的作用域来进行换源配置。最好的情况下，DefaultScope 是三者之一，
+ * 还有一个叫 ImplementationDefinedScope 的作用域，它不是一种新类型，而是表示根据实际情况决定的作用域。
+ * chsrc 将根据该 target 的实际情况来选择最合适的作用域来进行换源配置。最好的情况下，ImplementationDefinedScope 是三者之一，
  * 这也是这里设计的初衷。然而现在有些 recipe 的换源行为，会在某种 Scope 不能够成功时退而求其次地使用另一个 Scope
- * 来进行换源配置，这时 DefaultScope 就无法用一种作用域单独描述。
+ * 来进行换源配置，这时就只能用 ImplementationDefinedScope 来表示。
  */
 #define NumberOfScopeType    3
  typedef enum Scope_t
 {
-  DefaultScope, /* 默认作用域，即根据实际情况最佳的作用域，它不是一种类型，只类似一个占位符 */
-
   ProjectScope,
   UserScope,
   SystemScope,
+
+  /**
+   * 这是 target 默认的作用域，一种特殊的作用域，即根据 target 的实际情况来决定的。
+   * 它不是一种真正的类型，因为最终换源后，用户看到的作用域依然是 ProjectScope、UserScope 或 SystemScope 中的一个
+   */
+  ImplementationDefinedScope,
 }
 Scope_t;
 

src/recipe/lang/Java.c

@@ -24,7 +24,7 @@ pl_java_prelude ()
    * TODO: 当前实现将首先尝试 SystemScope, 若失败则尝试 UserScope
    * 所以并不是真正意义上的某种 Scope，而是两者的叠加，后续考虑强制执行用户所选择的 Scope 以达到用户期待
    */
-  chef_set_default_scope (this, SystemScope);
+  chef_set_default_scope (this, ImplementationDefinedScope);
 
   chef_deny_english(this);
   chef_allow_user_define(this);