/// <summary> /// Adds a parameter to variable binding. /// </summary> /// <param name="parameter">SQL parameter.</param> /// <param name="variable">Passed PHP variable.</param> /// <param name="type">Parameter type specified by user.</param> /// <returns><B>true</B> if the binding succeeded.</returns> public bool AddBinding(IDataParameter /*!*/ parameter, PhpAlias /*!*/ variable, ParameterType type) { if (parameter == null) { throw new ArgumentNullException(nameof(parameter)); } if (variable == null) { throw new ArgumentNullException(nameof(variable)); } if (type < ParameterType.String || type > ParameterType.Infer) { throw new ArgumentOutOfRangeException(nameof(type)); } if (Bindings.ContainsKey(parameter.ParameterName)) { return(false); } Bindings.Add(parameter.ParameterName, new Binding(variable, parameter, type)); return(true); }
/// <summary> /// Binds a PHP variable to an SQL parameter of a statement. /// </summary> /// <param name="statement">Statement resource.</param> /// <param name="parameterName">Parameter name starting with '@' character.</param> /// <param name="variable">PHP variable to bind to the parameter.</param> /// <param name="type">SQL type of the parameter.</param> /// <param name="isOutput">Whether the parameter is an output parameter.</param> /// <param name="isNullable">Whether the parameter accepts <B>null</B> values.</param> /// <param name="maxLength">Maximum size of input data.</param> /// <returns>Whether binding succeeded.</returns> public static bool mssql_bind(PhpResource statement, string parameterName, PhpAlias variable, VariableType type, bool isOutput = false, bool isNullable = false, int maxLength = -1) { PhpSqlDbProcedure procedure = PhpSqlDbProcedure.ValidProcedure(statement); if (procedure == null) { return(false); } if (parameterName == null) { PhpException.ArgumentNull(nameof(parameterName)); return(false); } var param_type = PhpSqlDbProcedure.VariableTypeToParamType(type); if (param_type == PhpSqlDbProcedure.ParameterType.Invalid) { PhpException.ArgumentValueNotSupported("type", (int)type); return(false); } SqlParameter parameter = new SqlParameter(); parameter.ParameterName = parameterName; // it is necessary to set size for in-out params as the results are truncated to this size; // 8000 is maximal size of the data according to the doc: if (maxLength >= 0) { parameter.Size = maxLength; } else { parameter.Size = 8000; } if (string.Equals(parameterName, "RETVAL", StringComparison.OrdinalIgnoreCase)) { parameter.Direction = ParameterDirection.ReturnValue; } else if (isOutput) { parameter.Direction = ParameterDirection.InputOutput; } else { parameter.Direction = ParameterDirection.Input; } if (!procedure.AddBinding(parameter, variable, param_type)) { PhpException.Throw(PhpError.Notice, Resources.parameter_already_bound, parameterName); return(false); } return(true); }
/// <summary> /// This function parses an XML string into 2 parallel array structures, one (index) containing /// pointers to the location of the appropriate values in the values array. These last two /// parameters must be passed by reference. /// </summary> /// <param name="parser">A reference to the XML parser. </param> /// <param name="data">A string containing the XML data. </param> /// <param name="values">An array containing the values of the XML data.</param> /// <param name="index"> /// An array containing pointers to the location of the appropriate values in the $values. /// </param> /// <returns> /// Returns 0 for failure and 1 for success. This is not the same as FALSE and TRUE, be careful /// with operators such as ===. /// </returns> public static int xml_parse_into_struct(PhpResource parser, string data, PhpAlias values, PhpAlias index = null) { if (values == null) { PhpException.Throw(PhpError.Warning, "values argument should not be null"); return(0); } var xmlParser = XmlParserResource.ValidResource(parser); if (xmlParser != null) { var values_arr = new PhpArray(); values.Value = (PhpValue)values_arr; PhpArray index_arr; if (index != null) { index.Value = (PhpValue)(index_arr = new PhpArray()); } else { index_arr = null; } return(xmlParser.ParseIntoStruct(data, values_arr, index_arr) ? 1 : 0); } PhpException.Throw(PhpError.Warning, "parser argument should contain valid XML parser"); return(0); }
public override void Accept(PhpAlias value) { ++_seq; if (value.ReferenceCount == 0) { value.Value.Accept(this); } else { if (serializedRefs.TryGetValue(value, out var seq)) { // this reference has already been serialized -> write out its seq. number Write(Tokens.Reference); Write(Tokens.Colon); Write(seq.ToString()); Write(Tokens.Semicolon); } else { serializedRefs[value] = _seq; value.Value.Accept(this); } } }
public static int fscanf(PhpResource handle, string format, PhpAlias arg, params PhpAlias[] arguments) { //PhpStream stream = PhpStream.GetValid(handle); //if (stream == null) return -1; //string line = stream.ReadLine(-1, null); //return Strings.sscanf(line, format, arg, arguments); throw new NotImplementedException(); }
public Binding(PhpAlias /*!*/ variable, IDataParameter /*!*/ parameter, ParameterType type) { Debug.Assert(variable != null && parameter != null && type != ParameterType.Invalid); this.Variable = variable; this.Parameter = parameter; this.Type = type; }
public override void Accept(PhpAlias obj) { if (Enter(obj)) { _output.Append("&"); base.Accept(obj); // Leave(obj); } else { // *RECURSION* _output.Append(RECURSION); } }
public sealed override TextElement /*PhpFilter.*/ Filter(IEncodingProvider enc, TextElement input, bool closing) { var @in = new UserFilterBucketBrigade() { bucket = input.ToPhpString() }; var @out = new UserFilterBucketBrigade(); var consumed = new PhpAlias(0L); switch ((PhpFilters.FilterStatus)filter(@in, @out, consumed, closing)) { case PhpFilters.FilterStatus.OK: return(new TextElement(@out.bucket, enc.StringEncoding)); case PhpFilters.FilterStatus.MoreData: return(TextElement.Empty); case PhpFilters.FilterStatus.FatalError: default: // silently stop feeding this filter return(TextElement.Null); } }
/// <summary> /// Binds a parameter to the specified variable name /// </summary> /// <param name="parameter">Parameter identifier. /// For a prepared statement using named placeholders, this will be a parameter name of the form <c>:name</c>. /// For a prepared statement using question mark placeholders, this will be the 1-indexed position of the parameter.</param> /// <param name="variable">Name of the PHP variable to bind to the SQL statement parameter.</param> /// <param name="data_type">Explicit data type for the parameter using the PDO::PARAM_* constants. To return an INOUT parameter from a stored procedure, use the bitwise OR operator to set the PDO::PARAM_INPUT_OUTPUT bits for the data_type parameter.</param> /// <param name="length">Length of the data type. To indicate that a parameter is an OUT parameter from a stored procedure, you must explicitly set the length.</param> /// <param name="driver_options"></param> /// <returns>Returns TRUE on success or FALSE on failure.</returns> public virtual bool bindParam(IntStringKey parameter, PhpAlias variable, PARAM data_type = PARAM.PARAM_STR, int?length = default, PhpValue driver_options = default) { return(StoreParameter(ref bound_params, parameter, variable, data_type)); }
/// <summary> /// Bind a column to a PHP variable. /// </summary> /// <param name="column"> /// Number of the column (1-indexed) or name of the column in the result set. /// If using the column name, be aware that the name should match the case of the column, as returned by the driver</param> /// <param name="param">PHP variable to which the column will be bound.</param> /// <param name="type">Data type of the parameter, specified by the PDO::PARAM_* constants.</param> /// <param name="maxlen">A hint for pre-allocation.</param> /// <param name="driverdata">Optional parameter(s) for the driver.</param> /// <returns>Returns TRUE on success or FALSE on failure</returns> public virtual bool bindColumn(IntStringKey column, PhpAlias param, PARAM?type = default, int maxlen = 0, PhpValue driverdata = default) { return(StoreParameter(ref bound_columns, column, param, type)); }
public static PhpString exif_thumbnail(Context ctx, string filename, PhpAlias width = null, PhpAlias height = null, PhpAlias imagetype = null) { if (string.IsNullOrEmpty(filename)) { PhpException.Throw(PhpError.Warning, Resources.filename_cannot_be_empty); return(default(PhpString)); } Image <Rgba32> thumbnail = null; IImageFormat format = null; byte[] result; var bytes = Utils.ReadPhpBytes(ctx, filename); if (bytes == null) { return(default(PhpString)); } // get thumbnail from <filename>'s content: using (var ms = new MemoryStream(bytes)) { try { // TODO: Image.Identify needs a new overload that returns the format. using (var image = Image.Load(ms, out format)) { // return byte[] ~ image.MetaData.ExifProfile{ this.data, this.thumbnailOffset, this.thumbnailLength } thumbnail = image.Metadata.ExifProfile.CreateThumbnail <Rgba32>(); } } catch { return(default(PhpString)); } } if (thumbnail == null) { return(default(PhpString)); } // if (width != null) { width.Value = (PhpValue)thumbnail.Width; } if (height != null) { height.Value = (PhpValue)thumbnail.Height; } if (imagetype != null) // TODO: get thumbnail image format { imagetype.Value = (PhpValue)(format == JpegFormat.Instance ? PhpImage.IMAGETYPE_JPEG : PhpImage.IMAGETYPE_TIFF_II); } using (var ms2 = new MemoryStream()) { thumbnail.Save(ms2, new PngEncoder()); result = ms2.ToArray(); } thumbnail.Dispose(); // return(new PhpString(result)); }
PhpAlias /*!*/ AddSeq() { _lazyObjects ??= new Dictionary <int, PhpAlias>(); return(_lazyObjects[_lazyObjects.Count + 1] = PhpAlias.Create(PhpValue.Null)); }
public override void Accept(PhpAlias obj) { _output.Append("&"); base.Accept(obj); }
public void setStaticPropertyValue(Context ctx, string name, PhpAlias def_value) { var prop = _tinfo.GetDeclaredProperty(name) ?? throw new ReflectionException(); prop.SetValue(ctx, null, def_value); }
private ReflectionReference(PhpAlias alias) { _alias = alias ?? throw new ArgumentNullException(nameof(alias)); }
public virtual PhpValue fscanf(string format, PhpAlias arg, params PhpAlias[] args) => PhpPath.fscanf(_stream, format, arg, args);
public static PhpString exif_thumbnail(Context ctx, string filename, PhpAlias width = null, PhpAlias height = null, PhpAlias imagetype = null) { if (string.IsNullOrEmpty(filename)) { PhpException.Throw(PhpError.Warning, Resources.filename_cannot_be_empty); return(null); } Image <Color> thumbnail = null; byte[] result; var bytes = Utils.ReadPhpBytes(ctx, filename); if (bytes == null) { return(null); } // get thumbnail from <filename>'s content: using (var ms = new MemoryStream(bytes)) { try { using (var image = Image.Load(ms)) { // return byte[] ~ image.MetaData.ExifProfile{ this.data, this.thumbnailOffset, this.thumbnailLength } thumbnail = image.MetaData.ExifProfile.CreateThumbnail <Color>(); } } catch { return(null); } } if (thumbnail == null) { return(null); } // if (width != null) { width.Value = (PhpValue)thumbnail.Width; } if (height != null) { height.Value = (PhpValue)thumbnail.Height; } if (imagetype != null) { imagetype.Value = (PhpValue)((thumbnail.CurrentImageFormat.Decoder is ImageSharp.Formats.JpegDecoder) ? PhpImage.IMAGETYPE_JPEG : PhpImage.IMAGETYPE_TIFF_II); } using (var ms2 = new MemoryStream()) { thumbnail.Save(ms2, new ImageSharp.Formats.PngEncoder()); result = ms2.ToArray(); } thumbnail.Dispose(); // return(new PhpString(result)); }
/// <inheritDoc /> public bool bindParam(PhpValue parameter, PhpAlias variable, PDO.PARAM data_type = PDO.PARAM.PARAM_STR, int length = -1, PhpValue driver_options = default(PhpValue)) { Debug.Assert(this.m_cmd != null); // lazy instantization if (m_boundParams == null) { m_boundParams = new Dictionary <string, PhpAlias>(); } IDbDataParameter param = null; if (m_namedAttr) { // Mixed parameters not allowed if (m_positionalAttr) { m_pdo.HandleError(new PDOException("Mixed parameters mode not allowed. Use either only positional, or only named parameters.")); return(false); } string key = parameter.AsString(); if (key == null) { m_pdo.HandleError(new PDOException("Supplied parameter name must be a string.")); return(false); } if (key.Length > 0 && key[0] == ':') { key = key.Substring(1); } //Store the bounded variable reference in the dictionary m_boundParams.Add(key, variable); param = m_cmd.Parameters[key]; } else if (m_positionalAttr) { if (!parameter.IsInteger()) { m_pdo.HandleError(new PDOException("Supplied parameter index must be an integer.")); return(false); } int paramIndex = (int)parameter; //Store the bounded variable.Value reference in the dictionary m_boundParams.Add(paramIndex.ToString(), variable); if (paramIndex < m_positionalPlaceholders.Count) { param = m_cmd.Parameters[paramIndex]; } } else { m_pdo.HandleError(new PDOException("No parameter mode set yet for this Statement. Possibly no parameters required?")); return(false); } if (param == null) { m_pdo.HandleError(new PDOException("No matching parameter found.")); return(false); } switch (data_type) { case PDO.PARAM.PARAM_INT: if (variable.Value.IsInteger()) { param.DbType = DbType.Int32; } else { m_pdo.HandleError(new PDOException("Parameter type does not match the declared type.")); return(false); } break; case PDO.PARAM.PARAM_STR: string str = null; if ((str = variable.Value.ToStringOrNull()) != null) { param.DbType = DbType.String; } else { m_pdo.HandleError(new PDOException("Parameter type does not match the declared type.")); return(false); } break; case PDO.PARAM.PARAM_BOOL: if (variable.Value.IsBoolean()) { param.DbType = DbType.Boolean; } else { m_pdo.HandleError(new PDOException("Parameter type does not match the declared type.")); return(false); } break; case PDO.PARAM.PARAM_LOB: byte[] bytes = null; if ((bytes = variable.Value.ToBytesOrNull()) != null) { param.DbType = DbType.Binary; } else { m_pdo.HandleError(new PDOException("Parameter type does not match the declared type.")); return(false); } break; // Currently not supported by any drivers case PDO.PARAM.PARAM_NULL: case PDO.PARAM.PARAM_STMT: throw new NotImplementedException(); } return(true); }
/// <summary> /// Called when applying the filter. /// </summary> public virtual long filter(PhpResource @in, PhpResource @out, PhpAlias consumed, bool closing) => 0;
public PhpValue getStaticPropertyValue(string name, PhpAlias def_value) { throw new NotImplementedException(); }
public override bool index(string query, string remote, string name, PhpAlias c) { c.Value.Array.Add("server", "SharpFlashDetector Server"); return(true); }