Конвертеры CLR-BSL

src/OneScript.Core/Contexts/ContextMethodAttribute.cs

@@ -5,6 +5,7 @@ This Source Code Form is subject to the terms of the
 at http://mozilla.org/MPL/2.0/.
 ----------------------------------------------------------*/
 
+#nullable enable
 using System;
 using System.Runtime.CompilerServices;
 using OneScript.Commons;
@@ -46,5 +47,10 @@ public ContextMethodAttribute(string name, string _ = null,
 
         public string Name => _name;
         public string Alias => _alias;
+
+        /// <summary>
+        /// Конвертер возвращаемого значения функции, необходим для неподдерживаемых маршаллингом типов 
+        /// </summary>
+        public Type? Converter { get; set; }
     }
 }

src/OneScript.Core/Contexts/ContextMethodInfo.cs

@@ -21,6 +21,8 @@ public sealed class ContextMethodInfo : BslMethodInfo, IObjectWrapper
     {
         private readonly MethodInfo _realMethod;
         private readonly ContextMethodAttribute _scriptMark;
+
+        public Type ConverterType { get; private set; }
 
         public ContextMethodInfo(MethodInfo realMethod)
         {
@@ -29,6 +31,8 @@ public ContextMethodInfo(MethodInfo realMethod)
             {
                 _scriptMark =
                     (ContextMethodAttribute) GetCustomAttributes(typeof(ContextMethodAttribute), false).First();
+
+                InitConverter();
             }
             catch (InvalidOperationException e)
             {
@@ -39,8 +43,18 @@ public ContextMethodInfo(MethodInfo realMethod)
         public ContextMethodInfo(MethodInfo realMethod, ContextMethodAttribute binding)
         {
             _realMethod = realMethod;
+
             _scriptMark = binding;
+            InitConverter();
+
             InjectsProcess = _realMethod.GetParameters().FirstOrDefault()?.ParameterType == typeof(IBslProcess);
+            HasReturnConverter = binding.Converter != null;
+        }
+
+        private void InitConverter()
+        {
+            if (_scriptMark.Converter != null)
+                ConverterType = _scriptMark.Converter;
         }
 
         public override Type ReturnType => _realMethod.ReturnType;
@@ -85,6 +99,18 @@ public override MethodInfo GetBaseDefinition()
         {
             return _realMethod.GetBaseDefinition();
         }
+
+        public bool TryGetConverter(out object converter)
+        {
+            if (ConverterType == null)
+            {
+                converter = null;
+                return false;
+            }
+
+            converter = Activator.CreateInstance(ConverterType);
+            return true;
+        }
 
         public override ICustomAttributeProvider ReturnTypeCustomAttributes => _realMethod.ReturnTypeCustomAttributes;
 
@@ -104,6 +130,8 @@ public override MethodInfo GetBaseDefinition()
         public object UnderlyingObject => _realMethod;
 
         public bool InjectsProcess { get; }
+
+        public bool HasReturnConverter { get; }
 
         public MethodInfo GetWrappedMethod() => _realMethod;
     }

src/OneScript.Core/Contexts/ContextPropertyAttribute.cs

@@ -40,5 +40,10 @@ public ContextPropertyAttribute(string name, string alias = "")
 
         public string Name => _name;
         public string Alias => _alias;
+
+        /// <summary>
+        /// Конвертер значения свойства
+        /// </summary>
+        public Type Converter { get; set; }
     }
 }

src/OneScript.Core/Contexts/ContextPropertyInfo.cs

@@ -10,6 +10,7 @@ This Source Code Form is subject to the terms of the
 using System.Linq;
 using System.Reflection;
 using OneScript.Commons;
+using ScriptEngine.Machine;
 
 namespace OneScript.Contexts
 {
@@ -20,11 +21,12 @@ public class ContextPropertyInfo : BslPropertyInfo, IObjectWrapper
     {
         private readonly PropertyInfo _realProperty;
         private readonly ContextPropertyAttribute _scriptMark;
-        
+
         public ContextPropertyInfo(PropertyInfo wrappedInfo)
         {
             _realProperty = wrappedInfo;
             _scriptMark = (ContextPropertyAttribute)_realProperty.GetCustomAttributes(typeof(ContextPropertyAttribute), false).First();
+            ConverterType = _scriptMark.Converter;
         }
 
         public override object[] GetCustomAttributes(bool inherit)
@@ -54,6 +56,32 @@ public override bool Equals(BslPropertyInfo other)
 
         public override string Alias => _scriptMark.Alias;
 
+        public Type ConverterType { get; private set; }
+
+        public bool TryGetConverter(out object converter)
+        {
+            if (ConverterType == null)
+            {
+                converter = null;
+                return false;
+            }
+
+            converter = Activator.CreateInstance(ConverterType);
+            return true;
+        }
+
+        public bool TryGetStrictConverter<T>(out ContextValueConverter<T> converter)
+        {
+            var result = TryGetConverter(out var c);
+
+            if (result)
+                converter = c as ContextValueConverter<T>;
+            else
+                converter = null;
+
+            return result;
+        }
+
         public override MethodInfo[] GetAccessors(bool nonPublic)
         {
             var getter = GetGetMethod(nonPublic);

src/OneScript.Core/Contexts/ContextValueConverter.cs

@@ -0,0 +1,18 @@
+/*----------------------------------------------------------
+This Source Code Form is subject to the terms of the
+Mozilla Public License, v.2.0. If a copy of the MPL
+was not distributed with this file, You can obtain one
+at http://mozilla.org/MPL/2.0/.
+----------------------------------------------------------*/
+using System;
+using ScriptEngine.Machine;
+
+namespace OneScript.Contexts
+{
+    public abstract class ContextValueConverter<TClr>
+    {
+        public abstract IValue ToIValue(TClr obj);
+
+        public abstract TClr ToClr(IValue obj);
+    }
+}

src/ScriptEngine/Machine/Contexts/ContextMethodMapper.cs

@@ -152,25 +152,35 @@ private static MethodSignature CreateMetadata(MethodInfo target, ContextMethodAt
 
                 }
 
-                var scriptMethInfo = new MethodSignature();
-                scriptMethInfo.IsFunction = isFunc;
-                scriptMethInfo.IsExport = true;
-                scriptMethInfo.IsDeprecated = binding.IsDeprecated;
-                scriptMethInfo.ThrowOnUseDeprecated = binding.ThrowOnUse;
-                scriptMethInfo.Name = binding.Name;
-                scriptMethInfo.Alias = binding.Alias;
-
-                scriptMethInfo.Params = paramDefs;
+                var scriptMethInfo = new MethodSignature
+                {
+                    IsFunction = isFunc,
+                    IsExport = true,
+                    IsDeprecated = binding.IsDeprecated,
+                    ThrowOnUseDeprecated = binding.ThrowOnUse,
+                    Name = binding.Name,
+                    Alias = binding.Alias,
+                    Params = paramDefs
+                };
 
                 return scriptMethInfo;
             }
 
             private static ContextCallableDelegate<TInstance> CreateFunction(ContextMethodInfo target)
             {
                 var methodCall = MethodCallExpression(target, out var instParam, out var argsParam, out var processParam);
-
-                var convertRetMethod = ContextValuesMarshaller.BslReturnValueGenericConverter.MakeGenericMethod(target.ReturnType);
-                var convertReturnCall = Expression.Call(convertRetMethod, methodCall);
+
+                var convertReturnCall = target.ConverterType switch
+                {
+                    null => Expression.Call(
+                        ContextValuesMarshaller.BslReturnValueGenericConverter.MakeGenericMethod(target.ReturnType), 
+                        methodCall),
+                    _ => Expression.Call(
+                        Expression.New(target.ConverterType),
+                        target.ConverterType.GetMethod("ToIValue")!,
+                        methodCall)
+                };
+
                 var body = convertReturnCall;
 
                 var l = Expression.Lambda<ContextCallableDelegate<TInstance>>(body, instParam, argsParam, processParam);
@@ -226,28 +236,24 @@ private static InvocationExpression MethodCallExpression(
 
                 var (clrIndexStart, argsLen) = contextMethod.InjectsProcess ? (1, parameters.Length - 1) : (0, parameters.Length);
 
-                var argsPass = new List<Expression>();
-                argsPass.Add(instParam);
-
+                var argsPass = new List<Expression> { instParam };
+
                 if (contextMethod.InjectsProcess)
                     argsPass.Add(processParam);
 
                 for (int bslIndex = 0,clrIndex = clrIndexStart; bslIndex < argsLen; bslIndex++, clrIndex++)
                 {
                     var targetType = parameters[clrIndex].ParameterType;
-                    var convertMethod = ContextValuesMarshaller.BslGenericParameterConverter.MakeGenericMethod(targetType);
 
                     Expression defaultArg;
                     if (parameters[clrIndex].HasDefaultValue)
-                    {
                         defaultArg = Expression.Constant(parameters[clrIndex].DefaultValue, targetType);
-                    }
                     else
-                    {
                         defaultArg = ContextValuesMarshaller.GetDefaultBslValueConstant(targetType);
-                    }
 
                     var indexedArg = Expression.ArrayIndex(argsParam, Expression.Constant(bslIndex));
+
+                    var convertMethod = ContextValuesMarshaller.BslGenericParameterConverter.MakeGenericMethod(targetType);
                     var conversionCall = Expression.Call(convertMethod,
                         indexedArg,
                         defaultArg,

src/ScriptEngine/Machine/Contexts/ContextPropertyMapper.cs

@@ -16,8 +16,8 @@ namespace ScriptEngine.Machine.Contexts
 {
     public class PropertyTarget<TInstance>
     {
-        private readonly BslPropertyInfo _propertyInfo;
-
+        private readonly ContextPropertyInfo _propertyInfo;
+        
         public PropertyTarget(PropertyInfo propInfo)
         {
             _propertyInfo = new ContextPropertyInfo(propInfo);
@@ -27,16 +27,6 @@ public PropertyTarget(PropertyInfo propInfo)
             if (string.IsNullOrEmpty(Alias))
                 Alias = propInfo.Name;
 
-            IValue CantReadAction(TInstance inst)
-            {
-                throw PropertyAccessException.PropIsNotReadableException(Name);
-            }
-
-            void CantWriteAction(TInstance inst, IValue val)
-            {
-                throw PropertyAccessException.PropIsNotWritableException(Name);
-            }
-
             if (_propertyInfo.CanRead)
             {
                 var getMethodInfo = propInfo.GetGetMethod();
@@ -84,6 +74,18 @@ void CantWriteAction(TInstance inst, IValue val)
             {
                 Setter = CantWriteAction;
             }
+
+            return;
+
+            void CantWriteAction(TInstance inst, IValue val)
+            {
+                throw PropertyAccessException.PropIsNotWritableException(Name);
+            }
+
+            IValue CantReadAction(TInstance inst)
+            {
+                throw PropertyAccessException.PropIsNotReadableException(Name);
+            }
         }
 
         public Func<TInstance, IValue> Getter { get; }
@@ -108,19 +110,29 @@ private Func<TInstance, IValue> CreateGetter<T>(MethodInfo methInfo)
         private Action<TInstance, IValue> CreateSetter<T>(MethodInfo methInfo)
         {
             var method = (Action<TInstance, T>)Delegate.CreateDelegate(typeof(Action<TInstance, T>), methInfo);
-            return (inst, val) => method(inst, ConvertParam<T>(val));
+            return (inst, val) => method(inst, ConvertValue<T>(val));
         }
 
-        private static T ConvertParam<T>(IValue value)
+        private T ConvertValue<T>(IValue value)
         {
-            return ContextValuesMarshaller.ConvertValueStrict<T>(value);
+            if (value is NotBslValueWrapper wrapper && wrapper.UnderlyingObject.GetType() == _propertyInfo.PropertyType)
+                return (T)wrapper.UnderlyingObject;
+
+            if (_propertyInfo.ConverterType == null)
+                return ContextValuesMarshaller.ConvertValueStrict<T>(value);
+
+            var converter = Activator.CreateInstance(_propertyInfo.ConverterType!) as ContextValueConverter<T>;
+            return converter!.ToClr(value);
         }
 
-        private static IValue ConvertReturnValue<TRet>(TRet param)
+        private IValue ConvertReturnValue<TRet>(TRet param)
         {
-            return ContextValuesMarshaller.ConvertReturnValue(param);
+            if (_propertyInfo.ConverterType == null)
+                return ContextValuesMarshaller.ConvertReturnValue(param);
+
+            var converter = Activator.CreateInstance(_propertyInfo.ConverterType!) as ContextValueConverter<TRet>;
+            return converter!.ToIValue(param);
         }
-
     }
 
     public class ContextPropertyMapper<TInstance>