public KumaException(KumaInstance obj)
{
var klass = obj.Class;
var exceptionFound = false;
var _class = obj.Class;
do
{
if (_class.Name.Equals("Exception"))
{
exceptionFound = true;
break;
}
_class = _class.Parent;
} while (!exceptionFound && _class != null);
if (exceptionFound)
{
ExceptionClass = klass;
InnerObject = obj;
}
else
{
ExceptionClass = Kuma.Box(typeof(KumaException));
InnerObject = null;
}
}
internal static dynamic DefineClassOpen(object rawValue, List <Expression> contents, object rawScope)
{
var scope = (KumaScope)rawScope;
var value = CompilerServices.CompileExpression((Expression)rawValue, scope);
if (value == null)
{
return(null);
}
var @class = value as KumaClass;
if (@class != null)
{
return(DefineCategory(@class, contents, scope));
}
var instance = value as KumaInstance;
if (instance != null)
{
return(DefineCategory(instance.Class, contents, scope));
}
var newVal = Kuma.Box(value);
return(DefineCategory(((KumaInstance)newVal).Class, contents, scope));
}
private static dynamic Compare(object left, object right, object rawScope)
{
var scope = (KumaScope)rawScope;
var KumaName = "<=>";
var clrName = InteropBinder.ToClrOperatorName(KumaName);
if (left is KumaInstance)
{
var lo = (KumaInstance)left;
var dmo = lo.GetMetaObject(Expression.Constant(left));
if (InteropBinder.InvokeMember.SearchForFunction(lo.Class, KumaName, lo, L(Arg(right)), true) != null)
{
return(dmo.BindInvokeMember(new InteropBinder.InvokeMember(KumaName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
if (InteropBinder.InvokeMember.SearchForFunction(lo.Class, clrName, lo, L(Arg(right)), true) != null)
{
return(dmo.BindInvokeMember(new InteropBinder.InvokeMember(clrName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
}
var Value = Kuma.Box(left);
if (Value.Class != null)
{
var _dmo = Value.GetMetaObject(Expression.Constant(Value));
if (InteropBinder.InvokeMember.SearchForFunction(Value.Class, KumaName, Value, L(Arg(right)), true) !=
null)
{
return(_dmo.BindInvokeMember(new InteropBinder.InvokeMember(KumaName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
if (InteropBinder.InvokeMember.SearchForFunction(Value.Class, clrName, Value, L(Arg(right)), true) !=
null)
{
return(_dmo.BindInvokeMember(new InteropBinder.InvokeMember(clrName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
}
dynamic _left = left;
dynamic _right = right;
if (_left < _right)
{
return(-1);
}
if (_left > _right)
{
return(1);
}
return(0);
}
internal static dynamic Resolve(object rawName, object rawScope)
{
if (rawName.GetType() == typeof(InstanceReference))
{
var iref = (InstanceReference)rawName;
var lval = CompilerServices.CompileExpression(iref.LValue, (KumaScope)rawScope);
var gmArgs = new List <Expression> ();
gmArgs.Add(Expression.Constant(lval, typeof(object)));
return(Dynamic(typeof(object), new InteropBinder.GetMember(iref.Key, (KumaScope)rawScope), gmArgs));
}
var name = (string)rawName;
var scope = (KumaScope)rawScope;
if (name.StartsWith("$") && name != "$:")
{
scope = scope.GlobalScope;
name = name.Substring(1);
}
if (name.StartsWith("@") && scope["<kuma_context_invokemember>"] != null)
{
if (name.StartsWith("@@"))
{
var _val = Resolve("self", scope);
if (!(_val is KumaInstance))
{
// native object?
_val = Kuma.Box((object)_val, scope);
}
var @class = ((KumaInstance)_val).Class;
return
(CompilerServices.CompileExpression(
KumaExpression.Variable(KumaExpression.InstanceRef(Expression.Constant(@class),
Expression.Constant(name.Substring(2)))), scope));
}
return
(CompilerServices.CompileExpression(
KumaExpression.Variable(
KumaExpression.InstanceRef(KumaExpression.Variable(Expression.Constant("self")),
Expression.Constant(name.Substring(1)))), scope));
}
var val = scope[name];
// The cast is needed here because if we get a non-nullable type (such as System.Int32) the check here will throw an exception.
// By casting to System.Object we can avoid the exception since it is a boxed value that can be null.
if ((object)val == null)
{
Type type;
if ((type = KumaTypeResolver.Resolve(name)) != null)
{
var @class = KumaClass.BoxClass(type);
scope.GlobalScope[@class.Name] = @class;
val = @class;
}
}
return(val);
}
internal static dynamic ObjectMethodChange(object rawSelf, object rawName, bool isRemove, object rawScope)
{
var scope = (KumaScope)rawScope;
var name = (string)rawName;
var self = CompilerServices.CompileExpression((Expression)rawSelf, scope);
var @class = self as KumaClass;
if (@class != null)
{
if (isRemove)
{
@class.RemovedMethods.Add(name);
}
else
{
@class.UndefinedMethods.Add(name);
}
}
else
{
var instance = self as KumaInstance;
if (instance != null)
{
if (isRemove)
{
instance.RemovedMethods.Add(name);
}
else
{
instance.UndefinedMethods.Add(name);
}
}
else
{
var newVal = Kuma.Box(self);
if (isRemove)
{
((KumaInstance)newVal).RemovedMethods.Add(name);
}
else
{
((KumaInstance)newVal).UndefinedMethods.Add(name);
}
}
}
return(null);
}
public void MergeWithScope(ScriptScope scope)
{
scope.GetVariableNames().ToList().ForEach(name => {
if (!Variables.ContainsKey(name))
{
var val = scope.GetVariable(name);
// Runtime classes we should wrap to get desired effect
if (val is KumaArray || val is KumaDictionary || val is KumaString || val is KumaNumber)
{
val = Kuma.Box(val);
}
Variables[name] = val;
}
});
}
public void MergeWithScope(Scope scope)
{
List <KeyValuePair <string, dynamic> > items = scope.Storage.GetItems();
foreach (var item in items)
{
if (!Variables.ContainsKey(item.Key))
{
var val = item.Value;
// Runtime classes we should wrap to get desired effect
if (val is KumaArray || val is KumaDictionary || val is KumaString || val is KumaNumber)
{
val = Kuma.Box(val);
}
Variables[item.Key] = val;
}
}
}
public Kernel()
{
KumaNativeFunction nfunc;
GetType().GetMethods(BindingFlags.Static | BindingFlags.NonPublic).ToList()
.ForEach(method => {
nfunc = new KumaNativeFunction(GetType(), method);
Kuma.Globals.SetVariable(nfunc.Name, nfunc);
});
// Register wrapper for functions which need it, like eval
var stream = typeof(Kernel).Assembly.GetManifestResourceStream("Kuma.Scripts.core.kuma");
var buffer = new byte[stream.Length];
stream.Read(buffer, 0, (int)stream.Length);
var source = Encoding.UTF8.GetString(buffer);
Kuma.Execute(source);
}
private static dynamic Match(object rawLeft, object rawRight, KumaExpressionType kumaBinaryNodeType, object rawScope)
{
var scope = (KumaScope)rawScope;
var left = CompilerServices.CompileExpression((Expression)rawLeft, scope);
var right = CompilerServices.CompileExpression((Expression)rawRight, scope);
var KumaName = "=~";
var clrName = InteropBinder.ToClrOperatorName(KumaName);
if (left is KumaInstance)
{
var lo = (KumaInstance)left;
DynamicMetaObject dmo = lo.GetMetaObject(Expression.Constant(left));
if (InteropBinder.InvokeMember.SearchForFunction(lo.Class, KumaName, lo, L(Arg(right)), true) != null)
{
if (kumaBinaryNodeType == KumaExpressionType.NotMatch)
{
return(!dmo.BindInvokeMember(new InteropBinder.InvokeMember(KumaName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
return(dmo.BindInvokeMember(new InteropBinder.InvokeMember(KumaName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
if (InteropBinder.InvokeMember.SearchForFunction(lo.Class, clrName, lo, L(Arg(right)), true) != null)
{
if (kumaBinaryNodeType == KumaExpressionType.NotMatch)
{
return(!dmo.BindInvokeMember(new InteropBinder.InvokeMember(clrName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
return(dmo.BindInvokeMember(new InteropBinder.InvokeMember(clrName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
}
var Value = Kuma.Box(left);
if (Value.Class != null)
{
var _dmo = Value.GetMetaObject(Expression.Constant(Value));
if (InteropBinder.InvokeMember.SearchForFunction(Value.Class, KumaName, Value, L(Arg(right)), true) !=
null)
{
if (kumaBinaryNodeType == KumaExpressionType.NotMatch)
{
return(!_dmo.BindInvokeMember(new InteropBinder.InvokeMember(KumaName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
return(_dmo.BindInvokeMember(new InteropBinder.InvokeMember(KumaName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
if (InteropBinder.InvokeMember.SearchForFunction(Value.Class, clrName, Value, L(Arg(right)), true) !=
null)
{
if (kumaBinaryNodeType == KumaExpressionType.NotMatch)
{
return(!_dmo.BindInvokeMember(new InteropBinder.InvokeMember(clrName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
return(_dmo.BindInvokeMember(new InteropBinder.InvokeMember(clrName, new CallInfo(1), scope),
_DMO(DMO(scope), DMO(Arg(right)))));
}
}
if (!(left is Regex || right is Regex))
{
return(null);
}
var left1 = left as Regex;
var regex = left1 ?? (Regex)right;
var str = (left is Regex) ? (string)right : (string)left;
if (!regex.Match(str).Success)
{
return(kumaBinaryNodeType == KumaExpressionType.NotMatch);
}
var groups = regex.Match(str).Groups;
foreach (var groupName in regex.GetGroupNames())
{
scope[groupName] = groups[groupName].Value;
}
return(kumaBinaryNodeType == KumaExpressionType.Match);
}
private static KumaClass GetBoxClass(object obj)
{
return(Kuma.Box(obj.GetType()));
}
internal static dynamic DefineClass(object rawName, object rawParent, List <Expression> contents, object rawScope)
{
lock (_classDefineLock) {
if (Resolve(rawName, rawScope) != null)
{
return(DefineCategory(Resolve(rawName, rawScope), contents, rawScope));
}
var scope = (KumaScope)rawScope;
var defineScope = _inClassDefine ? scope : scope.GlobalScope;
_inClassDefine = true;
KumaClass parent;
if (rawParent == null)
{
if (scope.GlobalScope["Object"] == null)
{
scope.GlobalScope["Object"] = Kuma.Box(typeof(object));
}
parent = scope.GlobalScope["Object"];
}
else
{
var dParent = Resolve(rawParent as string, scope);
if (dParent == null)
{
_inClassDefine = false;
return(null);
}
if (dParent is Type)
{
parent = Kuma.Box(dParent);
}
else
{
parent = dParent as KumaClass;
}
if (parent == null)
{
_inClassDefine = false;
return(null);
}
}
var name = (string)rawName;
_className = name;
var @class = new KumaClass {
Name = _className, Parent = parent
};
var xScope = new KumaScope(scope);
xScope["self"] = @class;
xScope[_className] = @class;
_currentClassScope = xScope;
contents.ForEach(content => {
if (content is IncludeExpression)
{
// We only include modules here so make sure this include references a module
var names = ((IncludeExpression)content).Names;
dynamic module = null;
var index = 0;
names.ForEach(mname => {
if ((module is KumaModule))
{
module = module.Context[mname];
}
else if (index == 0)
{
module = scope[mname];
}
index = index + 1;
});
if (module != null)
{
if (module is KumaModule)
{
((KumaModule)module).Contents.ForEach(mcon => {
if (mcon is KumaFunction)
{
if ((mcon as KumaFunction).IsSingleton ||
(mcon as KumaFunction).Name == "new")
{
KumaClass.AddMethod(@class.ClassMethods, mcon as KumaFunction);
}
else
{
KumaClass.AddMethod(@class.InstanceMethods, mcon as KumaFunction);
}
if (@class.RemovedMethods.Contains((mcon as KumaFunction).Name))
{
@class.RemovedMethods.Remove((mcon as KumaFunction).Name);
}
if (@class.UndefinedMethods.Contains((mcon as KumaFunction).Name))
{
@class.UndefinedMethods.Remove((mcon as KumaFunction).Name);
}
}
});
xScope.MergeWithScope(module.Context);
}
else if (module is KumaClass)
{
xScope[((KumaClass)module).Name] = module;
}
}
}
});
contents.ForEach(content => {
if (!(content is IncludeExpression))
{
var result = CompilerServices.CompileExpression(content, xScope);
if (result is KumaFunction)
{
if ((result as KumaFunction).IsSingleton || (result as KumaFunction).Name == "new")
{
KumaClass.AddMethod(@class.ClassMethods, result as KumaFunction);
}
else
{
KumaClass.AddMethod(@class.InstanceMethods, result as KumaFunction);
}
if (@class.RemovedMethods.Contains((result as KumaFunction).Name))
{
@class.RemovedMethods.Remove((result as KumaFunction).Name);
}
if (@class.UndefinedMethods.Contains((result as KumaFunction).Name))
{
@class.UndefinedMethods.Remove((result as KumaFunction).Name);
}
}
}
});
if ([email protected]("new"))
{
KumaClass.AddMethod(@class.ClassMethods, new KumaFunction("new", new List <FunctionArgument>(),
KumaExpression.KumaBlock(
KumaExpression.Return(new List <FunctionArgument> {
new FunctionArgument(null, KumaExpression.Variable(Expression.Constant("self")))
}),
Expression.Label(KumaParser.ReturnTarget, Expression.Constant(null, typeof(object)))),
new KumaScope()));
}
@class.Context = xScope;
defineScope[@class.Name] = @class;
_inClassDefine = false;
return(@class);
}
}
private static dynamic Box(object val)
{
return(Kuma.Box(val));
}
