/// <summary> /// Gets local configuration associated with a specified script context. /// </summary> /// <param name="context">Scritp context.</param> /// <returns>Local library configuration.</returns> public static MySqlLocalConfig GetLocal(ScriptContext/*!*/ context) { if (context == null) throw new ArgumentNullException("context"); return (MySqlLocalConfig)context.Config.GetLibraryConfig(MySqlLibraryDescriptor.Singleton); }
protected void Setup(ScriptContext c) { // Set a variable to the My Documents path. var section = (ClientSettingsSection)ConfigurationManager .GetSection("applicationSettings/wordpress.net.Properties.Settings"); var settings = section.Settings; foreach (SettingElement setting in settings) { var value = setting.Value.ValueXml.InnerText; if (!string.IsNullOrWhiteSpace(value)) { c.DefineConstant(setting.Name, setting.Value.ValueXml.InnerText); } else { switch (setting.Name) { case "ABSPATH": var path = System.IO.Directory.GetParent(Server.MapPath("~")).Parent.FullName + "\\components\\WordPress\\"; c.DefineConstant("ABSPATH", path.Replace("\\", "/")); break; } } } /** Sets up WordPress vars and included files. */ c.Include("..\\components\\WordPress\\wp-settings.php", true); }
public object __construct(ScriptContext __context, object name, [System.Runtime.InteropServices.OptionalAttribute()] object value) { string tmp1 = PhpVariable.AsString(name); if (tmp1 == null) { PhpException.InvalidImplicitCast(name, "string", "__construct"); return null; } string tmp2 = null; if (value != Arg.Default) { tmp2 = PhpVariable.AsString(value); if (tmp2 == null) { PhpException.InvalidImplicitCast(value, "string", "__construct"); return null; } } __construct(tmp1, tmp2); return null; }
public object fetch(ScriptContext context, object fetch_style/*=null*/, object cursor_orientation/*FETCH_ORI_NEXT*/, object cursor_offset/*0*/) { PDOFetchType ft; if (fetch_style == null || fetch_style == Arg.Default) fetch_style = this.m_pdo.getAttribute(context, (int)PDOAttributeType.PDO_ATTR_DEFAULT_FETCH_MODE); int fetch_style_int = PHP.Core.Convert.ObjectToInteger(fetch_style); if (!Enum.IsDefined(typeof(PDOFetchType), fetch_style_int)) { PDOException.Throw(context, "Invalid fetch_style value", null, null, null); return null; } ft = (PDOFetchType)fetch_style_int; var dr = this.CurrentReader; switch (ft) { case PDOFetchType.PDO_FETCH_ASSOC: return Fetch_Assoc(m_pdo.Driver, dr, false) ?? (object)false; case PDOFetchType.PDO_FETCH_NUM: return Fetch_Num(m_pdo.Driver, dr) ?? (object)false; case PDOFetchType.PDO_FETCH_BOTH: case PDOFetchType.PDO_FETCH_USE_DEFAULT: return Fetch_Assoc(m_pdo.Driver, dr, true) ?? (object)false; default: throw new NotImplementedException(); } }
public override object Quote(ScriptContext context, object strobj, PDOParamType param_type) { // From mysql extension // in addition, resulting string is quoted as '...' if (strobj == null) return string.Empty; // binary aware: if (strobj.GetType() == typeof(PhpBytes)) { var strbytes = (PhpBytes)strobj; if (strbytes.Length == 0) return strobj; var bytes = strbytes.ReadonlyData; List<byte>/*!*/result = new List<byte>(bytes.Length + 2); result.Add((byte)'\''); for (int i = 0; i < bytes.Length; i++) { switch (bytes[i]) { case (byte)'\0': result.Add((byte)'\\'); goto default; case (byte)'\\': result.Add((byte)'\\'); goto default; case (byte)'\n': result.Add((byte)'\\'); result.Add((byte)'n'); break; case (byte)'\r': result.Add((byte)'\\'); result.Add((byte)'r'); break; case (byte)'\u001a': result.Add((byte)'\\'); result.Add((byte)'Z'); break; case (byte)'\'': result.Add((byte)'\\'); goto default; case (byte)'"': result.Add((byte)'\\'); goto default; default: result.Add(bytes[i]); break; } } result.Add((byte)'\''); return new PhpBytes(result.ToArray()); } // else string str = Core.Convert.ObjectToString(strobj); StringBuilder sb = new StringBuilder(); sb.Append('\''); for (int i = 0; i < str.Length; i++) { char c = str[i]; switch (c) { case '\0': sb.Append(@"\0"); break; case '\\': sb.Append(@"\\"); break; case '\n': sb.Append(@"\n"); break; case '\r': sb.Append(@"\r"); break; case '\u001a': sb.Append(@"\Z"); break; case '\'': sb.Append(@"''"); break; case '"': sb.Append("\"\""); break; default: sb.Append(c); break; } } sb.Append('\''); return sb.ToString(); }
/// <summary> /// Initializes the script context for a web request. /// </summary> /// <param name="appContext">Application context.</param> /// <param name="context">HTTP context of the request.</param> /// <returns>A instance of <see cref="ScriptContext"/> to be used by the request.</returns> /// <exception cref="System.Configuration.ConfigurationErrorsException"> /// Web configuration is invalid. The context is not initialized then. /// </exception> internal static ScriptContext/*!*/ InitWebRequest(ApplicationContext/*!*/ appContext, HttpContext/*!*/ context) { Debug.Assert(appContext != null && context != null); // reloads configuration of the current thread from ASP.NET caches or web.config files; // cached configuration is reused; Configuration.Reload(appContext, false); // takes a writable copy of a global configuration (may throw ConfigurationErrorsException): LocalConfiguration config = (LocalConfiguration)Configuration.DefaultLocal.DeepCopy(); // following initialization statements shouldn't throw an exception: // can throw on Integrated Pipeline, events must be attached within HttpApplication.Init() ScriptContext result = new ScriptContext(appContext, config, context.Response.Output, context.Response.OutputStream); result.IsOutputBuffered = config.OutputControl.OutputBuffering; result.ThrowExceptionOnError = true; result.WorkingDirectory = Path.GetDirectoryName(context.Request.PhysicalPath); if (config.OutputControl.ContentType != null) context.Response.ContentType = config.OutputControl.ContentType; if (config.OutputControl.CharSet != null) context.Response.Charset = config.OutputControl.CharSet; result.AutoGlobals.Initialize(config, context); ScriptContext.CurrentContext = result; Externals.BeginRequest(); return result; }
public override void Load(string code = "") { try { context = ScriptContext.CurrentContext; context.Include(rpath + "\\" + Name + ".php", true); Class = (PhpObject) context.NewObject(Name); PHPGlobals = context.GlobalVariables; context.GlobalVariables.Add("Commands", chatCommands); context.GlobalVariables.Add("DataStore", DataStore.GetInstance()); context.GlobalVariables.Add("Find", Find.GetInstance()); context.GlobalVariables.Add("GlobalData", GlobalData); context.GlobalVariables.Add("Plugin", this); context.GlobalVariables.Add("Server", Pluton.Server.GetInstance()); context.GlobalVariables.Add("ServerConsoleCommands", consoleCommands); context.GlobalVariables.Add("Util", Util.GetInstance()); context.GlobalVariables.Add("Web", Web.GetInstance()); context.GlobalVariables.Add("World", World.GetInstance()); foreach (var x in PHPGlobals) { Globals.Add(x.Key.ToString()); } State = PluginState.Loaded; } catch (Exception ex) { Logger.LogException(ex); State = PluginState.FailedToLoad; } PluginLoader.GetInstance().OnPluginLoaded(this); }
private PhpCallback/*!*/ GetOrCreateFilterCallback(ScriptContext/*!*/ context) { if (filterCallback == null) filterCallback = new PhpCallback(new RoutineDelegate(Filter), context); return filterCallback; }
/// <summary> /// Creates a connection resource. /// </summary> /// <param name="connectionString">Connection string.</param> /// <param name="context">Script context associated with the connection.</param> public PhpMyDbConnection(string/*!*/ connectionString, ScriptContext/*!*/ context) : base(connectionString, new MySqlConnection(), "mysql connection") { if (context == null) throw new ArgumentNullException("context"); _context = context; _sharedConnection = false; }
/// <param name="context">A script context to get declarators from.</param> /// <param name="caller">A current type context.</param> public TypesProvider(ScriptContext/*!*/ context, DTypeDesc/*!*/ caller) { Debug.Assert(context != null && caller != null); this.context = context; this.caller = caller; Debug.WriteLine("PROVIDER", "created"); }
public override object GetLastInsertId(ScriptContext context, PDO pdo, string name) { var cmd = pdo.PDOConnection.LastCommand; if (cmd is MySqlCommand) return ((MySqlCommand)cmd).LastInsertedId; else return false; }
public object __construct(ScriptContext/*!*/context, object faultcode, object faultstring, [Optional]object faultactor, [Optional]object detail, [Optional]object faultname, [Optional]object headerfault) { base.__construct(context, faultstring, faultcode); return null; }
/// <summary> /// Creates a new connection resource. /// </summary> /// <param name="connectionString">Connection string.</param> /// <param name="context">Script context associated with the connection.</param> public PhpSqlDbConnection(string/*!*/ connectionString, ScriptContext/*!*/ context) : base(connectionString, new SqlConnection(), "mssql connection") { if (context == null) throw new ArgumentNullException("context"); this.context = context; // TODO: Connection.InfoMessage += new SqlInfoMessageEventHandler(InfoMessage); }
/// <summary> /// Constructor of PHP closure. /// </summary> /// <param name="context">Current <see cref="ScriptContext"/></param> /// <param name="lambda">Delegate to lambda function itself.</param> /// <param name="parameter"><see cref="PhpArray"/> of closure <c>parameter</c> field. Can be <c>null</c> if there are no parameters.</param> /// <param name="static"><see cref="PhpArray"/> of closure <c>parameter</c> field. Can be <c>null</c> if there is no <c>use</c> of scope variables.</param> public Closure(ScriptContext/*!*/context, RoutineDelegate/*!*/lambda, PhpArray parameter, PhpArray @static) :this(context, true) { Debug.Assert(context != null); Debug.Assert(lambda != null); this.lambda = lambda; this.parameter = parameter; this.@static = @static; }
// variables may be null when the code is global protected LinqContext(DObject outerType, Dictionary<string, object> variables, ScriptContext/*!*/ context, DTypeDesc typeHandle) { if (context == null) throw new ArgumentNullException("context"); this.variables = variables; this.outerType = outerType; this.context = context; this.typeHandle = typeHandle; }
/// <summary> /// Creates a new instance of <see cref="PhpStack"/>. /// </summary> /// <param name="context">The script context.</param> internal PhpStack(ScriptContext/*!*/ context) { Debug.Assert(context != null); this.Items = new object[25]; this.Types = new DTypeDesc[10]; this.Top = 0; this.TypesTop = 0; this.Context = context; }
public object item(ScriptContext __context, object index) { if (!(index is int)) { PhpException.InvalidImplicitCast(index, "int", "item"); return null; } return item((int)index); }
public object getNamedItem(ScriptContext __context, object name) { string tmp1 = PhpVariable.AsString(name); if (tmp1 == null) { PhpException.InvalidImplicitCast(name, "string", "getNamedItem"); return null; } return getNamedItem(tmp1); }
public object __construct(ScriptContext context, object argFileName, object argMode, object error) { string filename = PHP.Core.Convert.ObjectToString(argFileName); int mode = PHP.Core.Convert.ObjectToInteger(argMode); if (mode == 0) { mode = SQLite.DEFAULT_FILE_MODE; } this.m_filename = filename; this.m_con = SQLite.Open(this.m_filename, mode, error as PhpReference); return null; }
static HatenaSharp() { _context = ScriptContext.CurrentContext; DeclareType(typeof(HatenaSyntax)); DeclareType(typeof(HatenaSyntax_Renderer)); DeclareType(typeof(HatenaSyntax_Tree)); DeclareType(typeof(HatenaSyntax_Util)); DeclareType(typeof(PEG)); DeclareType(typeof(PEG_Util)); }
/// <summary> /// Load required zlib functions into the <paramref name="context"/>. /// </summary> public static void Load(ScriptContext/*!*/context) { Debug.Assert(context != null); Debug.Assert(!context.ApplicationContext.GetLoadedExtensions().Contains("zlib")); // - zlib.output_compression (ignore, always "") if (PHP.Library.IniOptions.GetOption("zlib.output_compression") == null) { lock (typeof(Zlib)) try { PHP.Library.IniOptions.Register("zlib.output_compression", PHP.Library.IniFlags.Supported, (config, option, value, action) => string.Empty, "zlib"); } catch { } } // - gzopen, gzclose, gzread, gzinflate DeclareFunction(context, "gzopen", NotSupportedFunction); DeclareFunction(context, "gzclose", NotSupportedFunction); DeclareFunction(context, "gzread", NotSupportedFunction); DeclareFunction(context, "gzinflate", (_, stack) => { if (stack.ArgCount != 1) return null; if (!(stack.PeekValue(1) is PhpBytes)) return false; var bytes = ((PhpBytes)stack.PeekValue(1)).ReadonlyData; try { List<byte>/*!*/inflate = new List<byte>(bytes.Length); using (var stream = new DeflateStream(new System.IO.MemoryStream(bytes), CompressionMode.Decompress)) { byte[] buffer = new byte[1024]; int n; while ((n = stream.Read(buffer, 0, buffer.Length)) > 0) inflate.AddRange(buffer.Take(n)); } return new PhpBytes(inflate.ToArray()); } catch (Exception ex) { PhpException.Throw(PhpError.Warning, "Error while decompressing gz stream: " + ex.Message); return false; } }); // - NS: gzdeflate, gzputs, gzwrite DeclareFunction(context, "gzdeflate", NotSupportedFunction); DeclareFunction(context, "gzputs", NotSupportedFunction); DeclareFunction(context, "gzwrite", NotSupportedFunction); }
/// <summary> /// Invoked when the instance is created (not called when unserialized). /// </summary> protected override void InstanceCreated(ScriptContext context) { base.InstanceCreated(context); PhpStackTrace trace = new PhpStackTrace(context, 1); PhpStackFrame frame = trace.GetFrame(0); Debug.Assert(frame != null); this.file.Value = frame.File; this.line.Value = frame.Line; this.column.Value = frame.Column; this.trace.Value = trace.GetUserTrace(); }
public object __construct(ScriptContext __context, object document) { DOMDocument tmp1 = document as DOMDocument; if (tmp1 == null) { PhpException.InvalidImplicitCast(document, "DOMDocument", "__construct"); return null; } __construct(tmp1); return null; }
public static void CleanDashboard(ScriptContext context) { dynamic wp = context.Globals; wp.add_action( "wp_dashboard_setup", new Action(() => { wp.remove_meta_box( "dashboard_primary", "dashboard", "side" ); wp.remove_meta_box( "dashboard_secondary", "dashboard", "side" ); wp.remove_meta_box( "dashboard_plugins", "dashboard", "normal" ); wp.remove_meta_box( "dashboard_incoming_links", "dashboard", "normal" ); })); }
internal static void Throw(ScriptContext/*!*/context, string faultcode, string faultstring, bool throwSoapFault=true) { if (throwSoapFault) { var e = new SoapFault(context, true); e.__construct(context, faultcode, faultstring); throw new PhpUserException(e); } else { PhpException.Throw(PhpError.Error, faultstring); } }
/// <summary> /// Load required Mbstring stuff into the <paramref name="context"/>. /// </summary> public static void Load(ScriptContext/*!*/context) { Debug.Assert(context != null); Debug.Assert(!context.ApplicationContext.GetLoadedExtensions().Contains("mbstring")); // mbstring.func_overload just return 0, so Phalanger won't throw warning(unlike PHP) if (PHP.Library.IniOptions.GetOption("mbstring.func_overload") == null) { lock (typeof(Mbstring)) try { PHP.Library.IniOptions.Register("mbstring.func_overload", PHP.Library.IniFlags.Supported, (config, option, value, action) => 0, "mbstring"); } catch { } } }
public override PDOConnection OpenConnection(ScriptContext context, string dsn_data, string username, string password, object argdriver_options) { //Determine file path string filename = dsn_data.Replace('/', Path.DirectorySeparatorChar); string filePath = Path.GetFullPath(Path.Combine(context.WorkingDirectory, filename)); SQLiteConnectionStringBuilder csb = new SQLiteConnectionStringBuilder(); csb.DataSource = filePath; csb.Version = 3; var con = new PDOConnection(csb.ConnectionString, new SQLiteConnection(), "PDO sqllite connection"); con.Connect(); return con; }
public static bool CreateClrThread(ScriptContext/*!*/context, PhpCallback/*!*/ callback, params object[] args) { if (callback == null) PhpException.ArgumentNull("callback"); if (!callback.Bind()) return false; object[] copies = (args != null) ? new object[args.Length] : ArrayUtils.EmptyObjects; for (int i = 0; i < copies.Length; i++) copies[i] = PhpVariable.DeepCopy(args[i]); return ThreadPool.QueueUserWorkItem(new Worker(context, copies).Run, callback); }
public object __construct(ScriptContext/*!*/context, object filename) { // check arguments string filenamestr = PhpVariable.AsString(filename); if (filenamestr == null) { PhpException.InvalidArgumentType("filename", PhpVariable.TypeNameString); } else { // TODO } return null; }
public object addAll(ScriptContext/*!*/context, object storage) { var data = asObjectStorage(storage); if (data != null) { foreach (var x in data.storage) { this.attach(context, x.Key, x.Value); } } else { // ... } return null; }
/// <summary> /// Walks the object graph rooted in this node. /// </summary> /// <param name="callback">The callback method.</param> /// <param name="context">Current <see cref="ScriptContext"/>.</param> public void Walk(PhpWalkCallback callback, ScriptContext context) { // PhpResources have no child objects, however as they constitute an interesting PHP type, // IPhpObjectGraphNode is implemented }
/// <summary> /// Sets a property of a <see cref="DObject"/> instance according to deserialized name and value. /// </summary> /// <param name="instance">The instance being deserialized.</param> /// <param name="name">The property name formatted for serialization (see <see cref="FormatPropertyName"/>).</param> /// <param name="value">The property value.</param> /// <param name="context">Current <see cref="ScriptContext"/>.</param> public static void SetProperty(DObject /*!*/ instance, string /*!*/ name, object value, ScriptContext /*!*/ context) { // the property name might encode its visibility and "classification" -> use these // information for suitable property desc lookups PhpMemberAttributes visibility; string type_name; string property_name = ParsePropertyName(name, out type_name, out visibility); DTypeDesc declarer; if (type_name == null) { declarer = instance.TypeDesc; } else { declarer = context.ResolveType(type_name); if (declarer == null) { declarer = instance.TypeDesc; } } // try to find a suitable field handle DPropertyDesc property; if (instance.TypeDesc.GetProperty(new VariableName(property_name), declarer, out property) == PHP.Core.Reflection.GetMemberResult.OK) { if ((property.IsPrivate && declarer != property.DeclaringType)) { // if certain conditions are met, don't use the handle even if it was found // (this is to precisely mimic the PHP behavior) property = null; } } else { property = null; } if (property != null) { property.Set(instance, value); } else { // suitable CT field not found -> add it to RT fields // (note: care must be taken so that the serialize(unserialize($x)) round // trip returns $x even if user classes specified in $x are not declared) if (instance.RuntimeFields == null) { instance.RuntimeFields = new PhpArray(); } instance.RuntimeFields[name] = value; } }
/// <summary> /// Returns names and values of properties whose names have been returned by <c>__sleep</c>. /// </summary> /// <param name="instance">The instance being serialized.</param> /// <param name="sleepResult">The array returned by <c>__sleep</c>.</param> /// <param name="context">Current <see cref="ScriptContext"/>.</param> /// <returns>Name-value pairs. Names are properly formatted for serialization.</returns> /// <exception cref="PhpException">Property of the name returned from <c>__sleep</c> does not exist.</exception> /// <remarks> /// This method returns exactly <paramref name="sleepResult"/>'s <see cref="PhpHashtable.Count"/> items. /// </remarks> public static IEnumerable <KeyValuePair <string, object> > EnumerateSerializableProperties( DObject /*!*/ instance, PhpArray /*!*/ sleepResult, ScriptContext /*!*/ context) { foreach (object item in sleepResult.Values) { PhpMemberAttributes visibility; string name = PHP.Core.Convert.ObjectToString(item); string declaring_type_name; string property_name = ParsePropertyName(name, out declaring_type_name, out visibility); DTypeDesc declarer; if (declaring_type_name == null) { declarer = instance.TypeDesc; } else { declarer = context.ResolveType(declaring_type_name); if (declarer == null) { // property name refers to an unknown class -> value will be null yield return(new KeyValuePair <string, object>(name, null)); continue; } } // obtain the property desc and decorate the prop name according to its visibility and declaring class DPropertyDesc property; if (instance.TypeDesc.GetProperty(new VariableName(property_name), declarer, out property) == GetMemberResult.OK && !property.IsStatic) { if ((Enums.VisibilityEquals(visibility, property.MemberAttributes) && visibility != PhpMemberAttributes.Public) || (visibility == PhpMemberAttributes.Private && declarer != property.DeclaringType)) { // if certain conditions are met, serialize the property as null // (this is to precisely mimic the PHP behavior) yield return(new KeyValuePair <string, object>(name, null)); continue; } name = FormatPropertyName(property, property_name); } else { property = null; } // obtain the property value object val = null; if (property != null) { val = property.Get(instance); } else if (instance.RuntimeFields == null || !instance.RuntimeFields.TryGetValue(name, out val)) { // this is new in PHP 5.1 PhpException.Throw(PhpError.Notice, CoreResources.GetString("sleep_returned_bad_field", name)); } yield return(new KeyValuePair <string, object>(name, val)); } }