public int GetDynamicSize(IMessageQueue queue, LuaObject propertyValue)
		{
			if (propertyValue.IsNil)
			{
				return queue.GetStringLength(null);
			}
			return queue.GetStringLength(propertyValue.AsString());
		}
 internal static LuaObject toNumber(LuaObject obj)
 {
     if (obj.IsNumber)
         return LuaObject.FromNumber(obj.AsNumber());
     if (obj.IsString)
     {
         double d;
         if (double.TryParse(obj.AsString(), out d))
             return LuaObject.FromNumber(d);
         return LuaObject.Nil;
     }
     return LuaObject.Nil;
 }
 internal static bool ConvertToNumber(LuaObject obj, out double value)
 {
     if (obj.IsNumber)
     {
         value = (double)obj.luaobj;
         return true;
     }
     if (obj.IsString)
     {
         if (double.TryParse(obj.AsString(), out value))
             return true;
         return false;
     }
     value = 0d;
     return false;
 }
Example #4
0
        public static async Task <LuaArguments> Gsub(Engine engine, string str, string pattern, LuaObject replacement, int?limit = null, CancellationToken token = default)
        {
            var regex = RegexUtils.FromPattern(pattern);

            return(await regex.ReplaceAsync(str, async match =>
            {
                if (replacement.IsFunction())
                {
                    return await replacement.CallAsync(engine, GetArgs(match), token).FirstAsync();
                }

                var repl = replacement.AsString();

                for (var i = 0; i < match.Groups.Count; i++)
                {
                    repl = repl.Replace($"%{i + 1}", match.Groups[i].Value);
                }

                return repl;
            }, limit));
        }
Example #5
0
        public virtual void Constant(LuaObject value)
        {
            switch (value.Type)
            {
            case LuaType.@string:
                stack.Push(Expression.Call(LuaObject_FromString, Expression.Constant(value.AsString())));
                break;

            case LuaType.number:
                stack.Push(Expression.Call(LuaObject_FromNumber, Expression.Constant(value.AsNumber())));
                break;

            case LuaType.function:
                // FIXME: we're actually creating a variable here..
                var fn   = value.AsFunction();
                var name = fn.Method.Name;
                CurrentScope.SetLocal(name, fn);
                Variable(name);
                break;

            default:
                throw new NotSupportedException(value.Type.ToString());
            }
        }
Example #6
0
 internal static LuaObject le_event(LuaObject op1, LuaObject op2)
 {
     if (op1.IsNumber && op2.IsNumber)
         return op1.AsNumber() <= op2.AsNumber();
     else if (op1.IsString && op2.IsString)
     {
         int n = StringComparer.CurrentCulture.Compare(op1.AsString(), op2.AsString());
         return (n <= 0);
     }
     else
     {
         var handler = getBinhandler(op1, op2, "__le");
         if (!handler.IsNil)
             return !(!(handler.Call(op1, op2)[0].AsBool()));
         else
             throw new ArgumentException("attempt to compare " + op1.type.ToString() + " with " + op2.type.ToString());
     }
 }
Example #7
0
 internal static LuaObject len_event(LuaObject op)
 {
     if (op.IsString)
         return op.AsString().Length;
     else
     {
         var handler = getMetamethod(op, "__len");
         if (!handler.IsNil)
             return handler.Call(op)[0];
         else if (op.IsTable)
             return op.AsTable().Count;
         else
             throw new LuaException("Invalid op");
     }
 }
		public virtual void Constant (LuaObject value)
		{
			switch (value.Type) {
			
			case LuaType.@string:
				stack.Push (Expression.Call (LuaObject_FromString, Expression.Constant (value.AsString ())));
				break;
				
			case LuaType.number:
				stack.Push (Expression.Call (LuaObject_FromNumber, Expression.Constant (value.AsNumber ())));
				break;
				
			case LuaType.function:
				// FIXME: we're actually creating a variable here..
				var fn = value.AsFunction ();
				var name = fn.Method.Name;
				CurrentScope.SetLocal (name, fn);
				Variable (name);
				break;
				
			default:
				throw new NotSupportedException (value.Type.ToString ());
			}
		}