新增UndefinedIdentifiersAsStrings

ExpressionElements/MemberElements/FunctionCall.cs

@@ -218,11 +218,15 @@ namespace Flee.ExpressionElements.MemberElements
                 return;
             }
 
+            // 允许void返回类型的函数，将其返回值视为0
+            // Void return type functions are allowed and treated as returning 0
+            /*
             // Any function reference in an expression must return a value
             if (object.ReferenceEquals(this.Method.ReturnType, typeof(void)))
             {
                 base.ThrowCompileException("FunctionHasNoReturnValue", CompileExceptionReason.FunctionHasNoReturnValue, MyName);
             }
+            */
         }
 
         public override void Emit(FleeILGenerator ilg, IServiceProvider services)
@@ -342,8 +346,22 @@ namespace Flee.ExpressionElements.MemberElements
                 this.EmitParamArrayArguments(parameters, elements, ilg, services);
             }
 
+            // 检查方法是否返回void
+            bool isVoidMethod = object.ReferenceEquals(this.Method.ReturnType, typeof(void));
+            
+            if (isVoidMethod)
+            {
+                // 对于void方法，使用原始的ReturnType调用方法，然后将0压入栈
+                MemberElement.EmitMethodCall(this.Method.ReturnType, nextRequiresAddress, this.Method, ilg);
+                // 将0压入栈作为返回值
+                ilg.Emit(OpCodes.Ldc_I4_0);
+            }
+            else
+            {
+                // 对于非void方法，正常调用
                 MemberElement.EmitMethodCall(this.ResultType, nextRequiresAddress, this.Method, ilg);
             }
+        }
 
         private void EmitExtensionFunctionInternal(ParameterInfo[] parameters, ExpressionElement[] elements, FleeILGenerator ilg, IServiceProvider services)
         {
@@ -397,6 +415,12 @@ namespace Flee.ExpressionElements.MemberElements
                 }
                 else
                 {
+                    // 如果方法返回void，将其视为返回int类型（值为0）
+                    // If method returns void, treat it as returning int (value 0)
+                    if (object.ReferenceEquals(this.Method.ReturnType, typeof(void)))
+                    {
+                        return typeof(int);
+                    }
                     return this.Method.ReturnType;
                 }
             }

ExpressionElements/MemberElements/Identifier.cs

@@ -25,6 +25,7 @@ namespace Flee.ExpressionElements.MemberElements
         private PropertyDescriptor _myPropertyDescriptor;
         private Type _myVariableType;
         private Type _myCalcEngineReferenceType;
+        private bool _isStringLiteral;
         public IdentifierElement(string name)
         {
             this.MyName = name;
@@ -60,6 +61,13 @@ namespace Flee.ExpressionElements.MemberElements
 
             if (MyPrevious == null)
             {
+                // 检查是否启用了未定义标识符作为字符串的选项
+                if (MyOptions.UndefinedIdentifiersAsStrings)
+                {
+                    // 将此标识符标记为字符串字面量
+                    _isStringLiteral = true;
+                    return;
+                }
                 base.ThrowCompileException("NoIdentifierWithName", CompileExceptionReason.UndefinedName, MyName);
             }
             else
@@ -140,6 +148,13 @@ namespace Flee.ExpressionElements.MemberElements
         {
             base.Emit(ilg, services);
 
+            // 如果是字符串字面量，直接发出字符串加载指令
+            if (_isStringLiteral)
+            {
+                ilg.Emit(OpCodes.Ldstr, MyName);
+                return;
+            }
+
             this.EmitFirst(ilg);
 
             if ((_myCalcEngineReferenceType != null))
@@ -354,6 +369,12 @@ namespace Flee.ExpressionElements.MemberElements
         {
             get
             {
+                // 如果是字符串字面量，返回 string 类型
+                if (_isStringLiteral)
+                {
+                    return typeof(string);
+                }
+                
                 if ((_myCalcEngineReferenceType != null))
                 {
                     return _myCalcEngineReferenceType;

PublicTypes/ExpressionOptions.cs

@@ -36,6 +36,7 @@ namespace Flee.PublicTypes
             _myProperties.SetToDefault<Type>("ResultType");
             _myProperties.SetToDefault<bool>("IsGeneric");
             _myProperties.SetToDefault<bool>("IntegersAsDoubles");
+            _myProperties.SetToDefault<bool>("UndefinedIdentifiersAsStrings");
             _myProperties.SetValue("ParseCulture", CultureInfo.CurrentCulture);
             this.SetParseCulture(this.ParseCulture);
             _myProperties.SetValue("RealLiteralDataType", RealLiteralDataType.Double);
@@ -149,6 +150,15 @@ namespace Flee.PublicTypes
             get { return _myProperties.GetValue<RealLiteralDataType>("RealLiteralDataType"); }
             set { _myProperties.SetValue("RealLiteralDataType", value); }
         }
+
+        /// <summary>
+        /// 当标识符未定义时，是否自动将其转换为字符串字面量
+        /// </summary>
+        public bool UndefinedIdentifiersAsStrings
+        {
+            get { return _myProperties.GetValue<bool>("UndefinedIdentifiersAsStrings"); }
+            set { _myProperties.SetValue("UndefinedIdentifiersAsStrings", value); }
+        }
         #endregion
 
         #region "Properties - Non Public"