示例#1
0
        /// <summary>
        /// Implements <c>+</c> operator on values.
        /// </summary>
        public static PhpArray Add(PhpArray x, PhpValue y)
        {
            var arr = y.AsArray();  // array or &array

            if (arr != null)
            {
                return(PhpArray.Union(x, arr));
            }

            //PhpException.UnsupportedOperandTypes();
            //return 0;
            throw new ArgumentException();  // TODO: ErrCode & return 0
        }
示例#2
0
        /// <summary>
        /// Implements <c>+</c> operator for unconvertible values or arrays.
        /// </summary>
        static PhpValue AddNonNumbers(ref PhpValue x, ref PhpValue y)
        {
            var arr_x = x.AsArray();
            var arr_y = y.AsArray();

            if (arr_x != null && arr_y != null)
            {
                return((PhpValue)PhpArray.Union(arr_x, arr_y));
            }

            //PhpException.UnsupportedOperandTypes();
            //return 0;
            throw new ArgumentException();  // TODO: ErrCode & return 0
        }
示例#3
0
文件: pcre.cs 项目: iolevel/peachpie
        /// <summary>
        /// Perform a regular expression search and replace.
        /// </summary>
        /// <param name="ctx">A reference to current context. Cannot be <c>null</c>.</param>
        /// <param name="pattern">The pattern to search for. It can be either a string or an array with strings.</param>
        /// <param name="replacement">The string or an array with strings to replace.
        /// If this parameter is a string and the pattern parameter is an array, all patterns will be
        /// replaced by that string. If both pattern and replacement parameters are arrays, each pattern will be
        /// replaced by the replacement counterpart. If there are fewer elements in the replacement array than
        /// in the pattern array, any extra patterns will be replaced by an empty string.</param>
        /// <param name="subject">The string or an array with strings to search and replace.
        /// If subject is an array, then the search and replace is performed on every entry of subject, and the return value is an array as well.</param>
        /// <param name="limit">The maximum possible replacements for each pattern in each subject string. Defaults to <c>-1</c> (no limit).</param>
        /// <param name="count">This variable will be filled with the number of replacements done.</param>
        /// <returns></returns>
        public static PhpValue preg_replace(Context ctx, PhpValue pattern, PhpValue replacement, PhpValue subject, int limit, out long count)
        {
            count = 0;

            // PHP's behaviour for undocumented limit range
            if (limit < -1)
            {
                limit = 0;
            }

            //
            var replacement_array = replacement.AsArray();
            var pattern_array = pattern.AsArray();

            if (pattern_array == null)
            {
                if (replacement_array == null)
                {
                    // string pattern
                    // string replacement

                    return preg_replace(ctx, pattern.ToStringOrThrow(ctx), replacement.ToStringOrThrow(ctx), null, subject, limit, ref count);
                }
                else
                {
                    // string pattern and array replacement not allowed:
                    throw new ArgumentException("replacement_array_pattern_not", nameof(replacement));
                    // return PhpValue.Null;
                }
            }
            else if (replacement_array == null)
            {
                // array  pattern
                // string replacement
            }
            else
            {
                // array pattern
                // array replacement
            }

            throw new NotImplementedException();
        }
示例#4
0
文件: pcre.cs 项目: iolevel/peachpie
        static PhpValue preg_replace(Context ctx, string pattern, string replacement, PhpCallable callback, PhpValue subject, int limit, ref long count)
        {
            var regex = new PerlRegex.Regex(pattern);

            // TODO: count
            // TODO: callback

            var subject_array = subject.AsArray();
            if (subject_array == null)
            {
                return PhpValue.Create(regex.Replace(subject.ToStringOrThrow(ctx), replacement, limit));
            }
            else
            {
                var arr = new PhpArray(subject_array, false);
                var enumerator = arr.GetFastEnumerator();
                while (enumerator.MoveNext())
                {
                    var newvalue = regex.Replace(enumerator.CurrentValue.ToStringOrThrow(ctx), replacement, limit);
                    enumerator.CurrentValue = PhpValue.Create(newvalue);
                }

                return PhpValue.Create(arr);
            }
        }
示例#5
0
 /// <summary>
 /// Casts value to <see cref="PhpArray"/> or <c>null</c>.
 /// </summary>
 public static PhpArray AsArray(PhpValue value) => value.AsArray();
示例#6
0
 /// <summary>
 /// Checks the value is of type <c>string</c> or <c>&amp;string</c> and gets its value.
 /// Single-byte strings are decoded using <c>UTF-8</c>.
 /// </summary>
 public static bool IsPhpArray(this PhpValue value, out PhpArray array) => (array = value.AsArray()) != null;
示例#7
0
 /// <summary>
 /// Gets the array access object.
 /// </summary>
 public static object AsArray(PhpValue value) => value.AsArray();
示例#8
0
        /// <summary>
        /// Sets variable's type.
        /// </summary>
        /// <param name="ctx">Current runtime context.</param>
        /// <param name="variable">The variable.</param>
        /// <param name="type">The string identifying a new type. See PHP manual for details.</param>
        /// <returns>Whether <paramref name="type"/> is valid type identifier.</returns>
        /// <exception cref="PhpException"><paramref name="type"/> has invalid value.</exception>
        public static bool settype(Context ctx, ref PhpValue variable, string type)
        {
            switch (type.ToLowerInvariant())
            {
                case "bool":
                case "boolean":
                    variable = PhpValue.Create(variable.ToBoolean());
                    return true;

                case "int":
                case "integer":
                    variable = PhpValue.Create(variable.ToLong());
                    return true;

                case "float":
                case "double":
                    variable = PhpValue.Create(variable.ToDouble());
                    return true;

                case "string":
                    variable = PhpValue.Create(variable.ToString(ctx));
                    return true;

                case "array":
                    variable = PhpValue.Create(variable.AsArray());
                    return true;

                case "object":
                    variable = PhpValue.FromClass(variable.ToClass());
                    return true;

                case "null":
                    variable = PhpValue.Null;
                    return true;
            }

            //PhpException.InvalidArgument("type", LibResources.GetString("invalid_type_name"));
            //return false;
            throw new ArgumentException(nameof(type));
        }
示例#9
0
 public static bool IsPhpArray(this PhpValue value, /*[MaybeNullWhen(false)]*/ out PhpArray?array) => (array = value.AsArray()) != null; // TODO: STANDARD21