예제 #1
0
파일: HashPType.cs 프로젝트: SealedSun/prx
 private static bool _tryConvertToPair(
     StackContext sctx, PValue inpv, out PValueKeyValuePair result)
 {
     PValue res;
     result = null;
     if (!inpv.TryConvertTo(sctx, typeof (PValueKeyValuePair), out res))
         return false;
     else
         result = (PValueKeyValuePair) res.Value;
     return true;
 }
예제 #2
0
파일: IntPType.cs 프로젝트: SealedSun/prx
        private static bool _tryConvertToInt(
            StackContext sctx, PValue operand, out int value, bool allowNull)
        {
            value = -1337; //should never surface as value is only used if the method returns true

            switch (operand.Type.ToBuiltIn())
            {
                case BuiltIn.Int:
                    value = Convert.ToInt32(operand.Value);
                    return true;
                    /*
                case BuiltIn.String:
                    string rawRight = operand.Value as string;
                    if (!int.TryParse(rawRight, out value))
                        value = 0;
                    return true; //*/
                case BuiltIn.Object:
                    PValue pvRight;
                    if (operand.TryConvertTo(sctx, Int, out pvRight))
                    {
                        value = (int) pvRight.Value;
                        return true;
                    }
                    break;
                case BuiltIn.Null:
                    value = 0;
                    return allowNull;
                default:
                    break;
            }

            return false;
        }
예제 #3
0
파일: CharPType.cs 프로젝트: SealedSun/prx
        private bool _tryConvert(StackContext sctx, PValue pv, out char c)
        {
            c = '\0';
            switch (pv.Type.ToBuiltIn())
            {
                case BuiltIn.Char:
                    c = (char) pv.Value;
                    return true;

                case BuiltIn.Int:
                    c = (char) (int) pv.Value;
                    return true;

                case BuiltIn.Null:
                    return true;

                case BuiltIn.String:
                    var s = (string) pv.Value;
                    if (s.Length == 1)
                    {
                        c = s[0];
                        return true;
                    }
                    else
                    {
                        return false;
                    }

                case BuiltIn.Object:
                    if (pv.TryConvertTo(sctx, Char, false, out pv))
                        return _tryConvert(sctx, pv, out c);
                    else
                        return false;

                case BuiltIn.Structure:
                case BuiltIn.Hash:
                case BuiltIn.List:
                case BuiltIn.Bool:
                case BuiltIn.None:
                case BuiltIn.Real:
                    return false;

                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
예제 #4
0
파일: Map.cs 프로젝트: SealedSun/prx
        /// <summary>
        ///     Tries to turn a generic PValue object into an <see cref = "IEnumerable{PValue}" /> if possible. Returns null if <paramref
        ///      name = "psource" /> cannot be enumerated over.
        /// </summary>
        /// <param name = "sctx"></param>
        /// <param name = "psource"></param>
        /// <returns></returns>
        internal static IEnumerable<PValue> _ToEnumerable(StackContext sctx, PValue psource)
        {
            switch (psource.Type.ToBuiltIn())
            {
                case PType.BuiltIn.List:
                    return (IEnumerable<PValue>) psource.Value;
                case PType.BuiltIn.Object:
                    var clrType = ((ObjectPType) psource.Type).ClrType;
                    if (typeof (IEnumerable<PValue>).IsAssignableFrom(clrType))
                        goto case PType.BuiltIn.List;
                    else if (typeof (IEnumerable).IsAssignableFrom(clrType))
                        return _wrapNonGenericIEnumerable(sctx, (IEnumerable) psource.Value);

                    break;
            }
            IEnumerable<PValue> set;
            IEnumerable nset;
            if (psource.TryConvertTo(sctx, true, out set))
                return set;
            else if (psource.TryConvertTo(sctx, true, out nset))
                return _wrapNonGenericIEnumerable(sctx, nset);
            else
                return _wrapDynamicIEnumerable(sctx, psource);
        }
예제 #5
0
파일: CallMacro.cs 프로젝트: SealedSun/prx
 private static EntityRef _getMacroRef(StackContext sctx, PValue rawMacro)
 {
     PFunction func;
     MacroCommand mcmd;
     if (rawMacro.TryConvertTo(sctx, out func))
         return EntityRef.Function.Create(func.Id, func.ParentApplication.Module.Name);
     else if (rawMacro.TryConvertTo(sctx, out mcmd))
         return EntityRef.MacroCommand.Create(mcmd.Id);
     else
         return rawMacro.ConvertTo<EntityRef>(sctx);
 }
예제 #6
0
파일: BoolPType.cs 프로젝트: SealedSun/prx
        private static bool _tryConvertToBool(StackContext sctx, PValue operand, out bool value)
        {
            value = false;

            switch (operand.Type.ToBuiltIn())
            {
                case BuiltIn.Real:
                case BuiltIn.Int:
                case BuiltIn.Bool:
                    value = (bool) operand.Value;
                    return true;
                case BuiltIn.String:
                    if (!bool.TryParse(operand.Value as string, out value))
                    {
                        value = false;
                        return true;
                    }
                    break;
                case BuiltIn.Object:
                    PValue asBool;
                    if (operand.TryConvertTo(sctx, Bool, out asBool))
                    {
                        value = (bool) asBool.Value;
                        return true;
                    }
                    break;
                case BuiltIn.Null:
                    value = false;
                    return true;
            }

            return false;
        }
예제 #7
0
파일: Round.cs 프로젝트: SealedSun/prx
        public static PValue RunStatically(PValue arg0, PValue arg1, StackContext sctx)
        {
            var x = (double) arg0.ConvertTo(sctx, PType.Real, true).Value;

            int d;
            PValue pd;

            if (arg1 != null && arg1.TryConvertTo(sctx, PType.Int, true, out pd))
                d = System.Math.Abs((int) pd.Value);
            else
                d = 0;

            return System.Math.Round(x, d, MidpointRounding.AwayFromZero);
        }