/// <summary> /// Overload of <see cref="ParseMode(string, StreamOpenOptions, out FileMode, out FileAccess, out StreamAccessOptions)"/> without the <c>out</c> arguments. /// </summary> /// <param name="mode">Mode as passed to <c>fopen()</c>.</param> /// <param name="options">The <see cref="StreamOpenOptions"/> passed to <c>fopen()</c>.</param> /// <param name="accessOptions">Resulting <see cref="StreamAccessOptions"/> giving /// additional information to the stream opener.</param> /// <returns><c>true</c> if the given mode was a valid file opening mode, otherwise <c>false</c>.</returns> /// <exception cref="ArgumentException">If the <paramref name="mode"/> is not valid.</exception> internal bool ParseMode(string mode, StreamOpenOptions options, out StreamAccessOptions accessOptions) { FileMode fileMode; FileAccess fileAccess; return(ParseMode(mode, options, out fileMode, out fileAccess, out accessOptions)); }
public override PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context) { int level = -1; var deflateMode = DeflateFilterMode.Normal; #region Parse mode options // PHP just looks whether there are mode flags in the mode string (skip the first character) // last flag is the valid one for (int i = 1; i < mode.Length; i++) { if (Char.IsDigit(mode[i])) { level = mode[i] - '0'; } else if (mode[i] == 'f') { deflateMode = DeflateFilterMode.Filter; } else if (mode[i] == 'h') { deflateMode = DeflateFilterMode.Huffman; } } #endregion #region Path correction if (path.StartsWith("compress.zlib://")) { path = path.Substring(16); } else if (path.StartsWith("zlib:")) { path = path.Substring(5); } #endregion var stream = PhpStream.Open(ctx, path, mode, options); if (stream != null && stream.CanRead) { stream.AddFilter(new GzipUncompressionFilter(), FilterChainOptions.Read); } if (stream != null && stream.CanWrite) { stream.AddFilter(new GzipCompresionFilter(level, deflateMode), FilterChainOptions.Write); } return(stream); }
public override PhpStream Open(ref string path, string mode, StreamOpenOptions options, StreamContext context) { int level = -1; DeflateFilterMode deflateMode = DeflateFilterMode.Normal; #region Parse mode options // PHP just looks whether there are mode flags in the mode string (skip the first character) // last flag is the valid one for (int i = 1; i < mode.Length; i++) { if (Char.IsDigit(mode[i])) { level = mode[i] - '0'; } else if (mode[i] == 'f') { deflateMode = DeflateFilterMode.Filter; } else if (mode[i] == 'h') { deflateMode = DeflateFilterMode.Huffman; } } #endregion #region Path correction if (path.StartsWith("compress.zlib://")) { path = path.Substring(16); } else if (path.StartsWith("zlib:")) { path = path.Substring(5); } #endregion PhpStream stream = PhpStream.Open(path, mode, options); if (stream != null && stream.CanRead) { stream.AddFilter(new GzipUncompressionFilter(), FilterChainOptions.Read); } if (stream != null && stream.CanWrite) { stream.AddFilter(new GzipCompresionFilter(level, deflateMode), FilterChainOptions.Write); } return stream; }
/// <include file='Doc/Wrappers.xml' path='docs/method[@name="Open"]/*'/> public override PhpStream Open(ref string path, string mode, StreamOpenOptions options, StreamContext context) { StreamAccessOptions accessOptions; if (!ParseMode(mode, options, out accessOptions)) { return(null); } string opened_path; IExternalStream stream = proxy.Open(path, mode, (int)options, out opened_path, null); path = opened_path; return(stream == null ? null : new ExternalStream(stream, this, accessOptions, opened_path, context)); }
/// <summary> /// Prevents invalid options from the the options argument for StreamWrapper.Open(). /// </summary> /// <param name="ctx">Runtime context.</param> /// <param name="flags">Flags passed to stream opening functions.</param> /// <returns>The StreamOpenFlags combination for the given arguments.</returns> static StreamOpenOptions ProcessOptions(Context ctx, FileOpenOptions flags) { StreamOpenOptions options = 0; if ((flags & FileOpenOptions.UseIncludePath) > 0) { options |= StreamOpenOptions.UseIncludePath; } if (!ctx.ErrorReportingDisabled) { options |= StreamOpenOptions.ReportErrors; } return(options); }
public override PhpStream Open(ref string path, string mode, StreamOpenOptions options, StreamContext context) { return null; }
public override PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context) { Debug.Assert(path != null); //Debug.Assert(PhpPath.IsLocalFile(path)); // Get the File.Open modes from the mode string FileMode fileMode; FileAccess fileAccess; StreamAccessOptions ao; if (!ParseMode(mode, options, out fileMode, out fileAccess, out ao)) { return(null); } // Open the native stream FileStream stream = null; try { // stream = File.Open(path, fileMode, fileAccess, FileShare.ReadWrite); stream = new FileStream(path, fileMode, fileAccess, FileShare.ReadWrite | FileShare.Delete); } catch (FileNotFoundException) { // Note: There may still be an URL in the path here. PhpException.Throw(PhpError.Warning, ErrResources.stream_file_not_exists, FileSystemUtils.StripPassword(path)); return(null); } catch (IOException e) { if ((ao & StreamAccessOptions.Exclusive) > 0) { PhpException.Throw(PhpError.Warning, ErrResources.stream_file_exists, FileSystemUtils.StripPassword(path)); } else { PhpException.Throw(PhpError.Warning, ErrResources.stream_file_io_error, FileSystemUtils.StripPassword(path), PhpException.ToErrorMessage(e.Message)); } return(null); } catch (UnauthorizedAccessException) { PhpException.Throw(PhpError.Warning, ErrResources.stream_file_access_denied, FileSystemUtils.StripPassword(path)); return(null); } catch (Exception) { PhpException.Throw(PhpError.Warning, ErrResources.stream_file_invalid, FileSystemUtils.StripPassword(path)); return(null); } if ((ao & StreamAccessOptions.SeekEnd) > 0) { // Read/Write Append is not supported. Seek to the end of file manually. stream.Seek(0, SeekOrigin.End); } if ((ao & StreamAccessOptions.Temporary) > 0) { // Set the file attributes to Temporary too. File.SetAttributes(path, FileAttributes.Temporary); } return(new NativeStream(ctx, stream, this, ao, path, context)); }
public abstract PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context);
/// <summary> /// Overload of <see cref="ParseMode(string, StreamOpenOptions, out FileMode, out FileAccess, out StreamAccessOptions)"/> without the <c>out</c> arguments. /// </summary> /// <param name="mode">Mode as passed to <c>fopen()</c>.</param> /// <param name="options">The <see cref="StreamOpenOptions"/> passed to <c>fopen()</c>.</param> /// <param name="accessOptions">Resulting <see cref="StreamAccessOptions"/> giving /// additional information to the stream opener.</param> /// <returns><c>true</c> if the given mode was a valid file opening mode, otherwise <c>false</c>.</returns> /// <exception cref="ArgumentException">If the <paramref name="mode"/> is not valid.</exception> internal bool ParseMode(string mode, StreamOpenOptions options, out StreamAccessOptions accessOptions) { FileMode fileMode; FileAccess fileAccess; return (ParseMode(mode, options, out fileMode, out fileAccess, out accessOptions)); }
/// <summary> /// Openes a PhpStream using the appropriate StreamWrapper. /// </summary> /// <param name="ctx">Current runtime context.</param> /// <param name="path">URI or filename of the resource to be opened.</param> /// <param name="mode">A file-access mode as passed to the PHP function.</param> /// <param name="options">A combination of <see cref="StreamOpenOptions"/>.</param> /// <param name="context">A valid StreamContext. Must not be <c>null</c>.</param> /// <returns></returns> public static PhpStream Open(Context ctx, string path, string mode, StreamOpenOptions options, StreamContext context) { if (context == null) throw new ArgumentNullException("context"); Debug.Assert(ctx != null); StreamWrapper wrapper; if (!PhpStream.ResolvePath(ctx, ref path, out wrapper, CheckAccessMode.FileMayExist, (CheckAccessOptions)options)) return null; return wrapper.Open(ctx, ref path, mode, options, context); }
public override PhpStream Open(ref string path, string mode, StreamOpenOptions options, StreamContext context) { //From filestreamwrapper Debug.Assert(path != null); //Debug.Assert(PhpPath.IsLocalFile(path)); // Get the File.Open modes from the mode string FileMode fileMode; FileAccess fileAccess; StreamAccessOptions ao; if (!ParseMode(mode, options, out fileMode, out fileAccess, out ao)) { return(null); } string[] arr = path.Split('#'); string archive = arr[0]; string entry = arr[1]; // Open the native stream ZipFile zip = null; try { // stream = File.Open(path, fileMode, fileAccess, FileShare.ReadWrite); zip = new ZipFile(File.Open(archive, FileMode.Open, FileAccess.Read, FileShare.Read)); } catch (FileNotFoundException) { // Note: There may still be an URL in the path here. PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_not_exists", FileSystemUtils.StripPassword(path))); return(null); } catch (IOException e) { if ((ao & StreamAccessOptions.Exclusive) > 0) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_exists", FileSystemUtils.StripPassword(path))); } else { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_io_error", FileSystemUtils.StripPassword(path), PhpException.ToErrorMessage(e.Message))); } return(null); } catch (UnauthorizedAccessException) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_access_denied", FileSystemUtils.StripPassword(path))); return(null); } catch (Exception) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_invalid", FileSystemUtils.StripPassword(path))); return(null); } if ((ao & StreamAccessOptions.SeekEnd) > 0) { throw new NotSupportedException(); } if ((ao & StreamAccessOptions.Temporary) > 0) { // Set the file attributes to Temporary too. throw new NotSupportedException(); } if (zip == null) { return(null); } ZipEntry zEntry = zip.GetEntry(entry); if (zEntry == null) { return(null); } Stream s = zip.GetInputStream(zEntry); return(new NativeStream(s, this, ao, path, context)); }
public override PhpStream Open(ref string path, string mode, StreamOpenOptions options, StreamContext context) { //From filestreamwrapper Debug.Assert(path != null); //Debug.Assert(PhpPath.IsLocalFile(path)); // Get the File.Open modes from the mode string FileMode fileMode; FileAccess fileAccess; StreamAccessOptions ao; if (!ParseMode(mode, options, out fileMode, out fileAccess, out ao)) return null; string[] arr = path.Split('#'); string archive = arr[0]; string entry = arr[1]; // Open the native stream ZipFile zip = null; try { // stream = File.Open(path, fileMode, fileAccess, FileShare.ReadWrite); zip = new ZipFile(File.Open(archive, FileMode.Open, FileAccess.Read, FileShare.Read)); } catch (FileNotFoundException) { // Note: There may still be an URL in the path here. PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_not_exists", FileSystemUtils.StripPassword(path))); return null; } catch (IOException e) { if ((ao & StreamAccessOptions.Exclusive) > 0) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_exists", FileSystemUtils.StripPassword(path))); } else { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_io_error", FileSystemUtils.StripPassword(path), PhpException.ToErrorMessage(e.Message))); } return null; } catch (UnauthorizedAccessException) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_access_denied", FileSystemUtils.StripPassword(path))); return null; } catch (Exception) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_invalid", FileSystemUtils.StripPassword(path))); return null; } if ((ao & StreamAccessOptions.SeekEnd) > 0) { throw new NotSupportedException(); } if ((ao & StreamAccessOptions.Temporary) > 0) { // Set the file attributes to Temporary too. throw new NotSupportedException(); } if (zip == null) { return null; } ZipEntry zEntry = zip.GetEntry(entry); if (zEntry == null) { return null; } Stream s = zip.GetInputStream(zEntry); return new NativeStream(s, this, ao, path, context); }
public override PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context) { if (TryResolvePhar(ctx, path.AsSpan(), out var phar, out var entry)) { // Template: phar://alias/entryName var resource = PharExtensions.GetResourceStream(phar, entry); if (resource != null) { return(new NativeStream(ctx, resource, this, StreamAccessOptions.UseText | StreamAccessOptions.Read, path, context)); } else { // TODO: entry not found } }
public override PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context) { if (FileSystemUtils.TryGetScheme(path, out var schemespan)) { var schemeends = schemespan.Length + 3; var sep = path.IndexOfAny(PathUtils.DirectorySeparatorChars, schemeends); if (sep >= 0) { Stream resource = null; var alias = path.Substring(schemeends, sep - schemeends); var pharFile = PharExtensions.AliasToPharFile(ctx, alias); if (pharFile != null) { // Template: phar://alias/entryName resource = PharExtensions.GetResourceStream(pharFile, path.Substring(sep + 1)); } else { // Template: phar://path_phar_file/entryName var pharExt = path.IndexOfOrdinal(PharExtensions.PharExtension, schemeends, path.Length - schemeends); if (pharExt >= 0 && pharExt + PharExtensions.PharExtension.Length + 1 < path.Length) { // path_phar_file: var pharPath = path.Substring(schemeends, pharExt + PharExtensions.PharExtension.Length - schemeends); // entryName: var entryName = path.Substring(pharExt + PharExtensions.PharExtension.Length + 1); // ensure phar is loaded // TODO: locate pharPath and get containing System.Reflection.Assembly throw new NotImplementedException(); } } if (resource != null) { return(new NativeStream(ctx, resource, this, StreamAccessOptions.UseText | StreamAccessOptions.Read, path, context)); } } } return(null); }
public override PhpStream Open(Context ctx, ref string path, string mode, StreamOpenOptions options, StreamContext context) { return(null); }
public static PhpStream Open(Context ctx, string path, string mode, StreamOpenOptions options) { return Open(ctx, path, mode, options, StreamContext.Default); }
/// <summary> /// Parse the <paramref name="mode"/> argument passed to <c>fopen()</c> /// and make the appropriate <see cref="FileMode"/> and <see cref="FileAccess"/> /// combination. /// Integrate the relevant options from <see cref="StreamOpenOptions"/> too. /// </summary> /// <param name="mode">Mode as passed to <c>fopen()</c>.</param> /// <param name="options">The <see cref="StreamOpenOptions"/> passed to <c>fopen()</c>.</param> /// <param name="fileMode">Resulting <see cref="FileMode"/> specifying opening mode.</param> /// <param name="fileAccess">Resulting <see cref="FileAccess"/> specifying read/write access options.</param> /// <param name="accessOptions">Resulting <see cref="StreamAccessOptions"/> giving /// additional information to the stream opener.</param> /// <returns><c>true</c> if the given mode was a valid file opening mode, otherwise <c>false</c>.</returns> public bool ParseMode(string mode, StreamOpenOptions options, out FileMode fileMode, out FileAccess fileAccess, out StreamAccessOptions accessOptions) { accessOptions = StreamAccessOptions.Empty; bool forceBinary = false; // The user requested a text stream bool forceText = false; // Use text access to the stream (default is binary) // First check for relevant options in StreamOpenOptions: // Search for the file only if mode=='[ra]*' and use_include_path==true. // StreamAccessOptions findFile = 0; if ((options & StreamOpenOptions.UseIncludePath) > 0) { // findFile = StreamAccessOptions.FindFile; accessOptions |= StreamAccessOptions.FindFile; } // Copy the AutoRemove option. if ((options & StreamOpenOptions.Temporary) > 0) { accessOptions |= StreamAccessOptions.Temporary; } // Now do the actual mode parsing: fileMode = FileMode.Open; fileAccess = FileAccess.Write; if (String.IsNullOrEmpty(mode)) { PhpException.Throw(PhpError.Warning, ErrResources.empty_file_mode); return(false); } switch (mode[0]) { case 'r': // flags = 0; // fileMode is already set to Open fileAccess = FileAccess.Read; //accessOptions |= findFile; break; case 'w': // flags = O_TRUNC|O_CREAT; // fileAccess is set to Write fileMode = FileMode.Create; //accessOptions |= findFile; // EX: Note that use_include_path is applicable to all access methods. // Create truncates the existing file to zero length break; case 'a': // flags = O_CREAT|O_APPEND; // fileAccess is set to Write fileMode = FileMode.Append; //accessOptions |= findFile; // Note: .NET does not support the "a+" mode, use "r+" and Seek() break; case 'x': // flags = O_CREAT|O_EXCL; // fileAccess is set to Write fileMode = FileMode.CreateNew; accessOptions |= StreamAccessOptions.Exclusive; break; default: PhpException.Throw(PhpError.Warning, ErrResources.invalid_file_mode, mode); return(false); } if (mode.IndexOf('+') > -1) { // flags |= O_RDWR; fileAccess = FileAccess.ReadWrite; } if ((fileMode == FileMode.Append) && (fileAccess == FileAccess.ReadWrite)) { // Note: .NET does not support the "a+" mode, use "r+" and Seek() fileMode = FileMode.OpenOrCreate; fileAccess = FileAccess.ReadWrite; accessOptions |= StreamAccessOptions.SeekEnd; } if (mode.IndexOf('b') > -1) { // flags |= O_BINARY; forceBinary = true; } if (mode.IndexOf('t') > -1) { // flags |= _O_TEXT; forceText = true; } // Exactly one of these options is required. if ((forceBinary && forceText) || (!forceBinary && !forceText)) { //LocalConfiguration config = Configuration.Local; //// checks whether default mode is applicable: //if (config.FileSystem.DefaultFileOpenMode == "b") //{ // forceBinary = true; //} //else if (config.FileSystem.DefaultFileOpenMode == "t") //{ // forceText = true; //} //else //{ // PhpException.Throw(PhpError.Warning, ErrResources.ambiguous_file_mode, mode); //} throw new NotImplementedException("Configuration.FileSystem.DefaultFileOpenMode"); // Binary mode is assumed } else if (forceText) { // Default mode is binary (unless the text mode is specified). accessOptions |= StreamAccessOptions.UseText; } // Store the two file-access flags into the access options too. accessOptions |= (StreamAccessOptions)fileAccess; return(true); }
/// <include file='Doc/Wrappers.xml' path='docs/method[@name="Open"]/*'/> public override PhpStream Open(ref string path, string mode, StreamOpenOptions options, StreamContext context) { Debug.Assert(path != null); //Debug.Assert(PhpPath.IsLocalFile(path)); // Get the File.Open modes from the mode string FileMode fileMode; FileAccess fileAccess; StreamAccessOptions ao; if (!ParseMode(mode, options, out fileMode, out fileAccess, out ao)) return null; // Open the native stream this.storageFile = IsolatedStorageFile.GetUserStoreForApplication(); FileStream stream = null; try { stream = new IsolatedStorageFileStream(path, fileMode, fileAccess, FileShare.ReadWrite | FileShare.Delete, storageFile); } catch (FileNotFoundException) { // Note: There may still be an URL in the path here. PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_not_exists", FileSystemUtils.StripPassword(path))); return null; } catch (IOException e) { if ((ao & StreamAccessOptions.Exclusive) > 0) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_exists", FileSystemUtils.StripPassword(path))); } else { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_io_error", FileSystemUtils.StripPassword(path), PhpException.ToErrorMessage(e.Message))); } return null; } catch (UnauthorizedAccessException) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_access_denied", FileSystemUtils.StripPassword(path))); return null; } catch (Exception) { PhpException.Throw(PhpError.Warning, CoreResources.GetString("stream_file_invalid", FileSystemUtils.StripPassword(path))); return null; } if ((ao & StreamAccessOptions.SeekEnd) > 0) { // Read/Write Append is not supported. Seek to the end of file manually. stream.Seek(0, SeekOrigin.End); } if ((ao & StreamAccessOptions.Temporary) > 0) { // Set the file attributes to Temporary too. File.SetAttributes(path, FileAttributes.Temporary); } return new NativeStream(stream, this, ao, path, context); }
/// <summary> /// Parse the <paramref name="mode"/> argument passed to <c>fopen()</c> /// and make the appropriate <see cref="FileMode"/> and <see cref="FileAccess"/> /// combination. /// Integrate the relevant options from <see cref="StreamOpenOptions"/> too. /// </summary> /// <param name="mode">Mode as passed to <c>fopen()</c>.</param> /// <param name="options">The <see cref="StreamOpenOptions"/> passed to <c>fopen()</c>.</param> /// <param name="fileMode">Resulting <see cref="FileMode"/> specifying opening mode.</param> /// <param name="fileAccess">Resulting <see cref="FileAccess"/> specifying read/write access options.</param> /// <param name="accessOptions">Resulting <see cref="StreamAccessOptions"/> giving /// additional information to the stream opener.</param> /// <returns><c>true</c> if the given mode was a valid file opening mode, otherwise <c>false</c>.</returns> public bool ParseMode(string mode, StreamOpenOptions options, out FileMode fileMode, out FileAccess fileAccess, out StreamAccessOptions accessOptions) { accessOptions = StreamAccessOptions.Empty; bool forceBinary = false; // The user requested a text stream bool forceText = false; // Use text access to the stream (default is binary) // First check for relevant options in StreamOpenOptions: // Search for the file only if mode=='[ra]*' and use_include_path==true. // StreamAccessOptions findFile = 0; if ((options & StreamOpenOptions.UseIncludePath) > 0) { // findFile = StreamAccessOptions.FindFile; accessOptions |= StreamAccessOptions.FindFile; } // Copy the AutoRemove option. if ((options & StreamOpenOptions.Temporary) > 0) { accessOptions |= StreamAccessOptions.Temporary; } // Now do the actual mode parsing: fileMode = FileMode.Open; fileAccess = FileAccess.Write; if (String.IsNullOrEmpty(mode)) { PhpException.Throw(PhpError.Warning, ErrResources.empty_file_mode); return false; } switch (mode[0]) { case 'r': // flags = 0; // fileMode is already set to Open fileAccess = FileAccess.Read; //accessOptions |= findFile; break; case 'w': // flags = O_TRUNC|O_CREAT; // fileAccess is set to Write fileMode = FileMode.Create; //accessOptions |= findFile; // EX: Note that use_include_path is applicable to all access methods. // Create truncates the existing file to zero length break; case 'a': // flags = O_CREAT|O_APPEND; // fileAccess is set to Write fileMode = FileMode.Append; //accessOptions |= findFile; // Note: .NET does not support the "a+" mode, use "r+" and Seek() break; case 'x': // flags = O_CREAT|O_EXCL; // fileAccess is set to Write fileMode = FileMode.CreateNew; accessOptions |= StreamAccessOptions.Exclusive; break; default: PhpException.Throw(PhpError.Warning, ErrResources.invalid_file_mode, mode); return false; } if (mode.IndexOf('+') > -1) { // flags |= O_RDWR; fileAccess = FileAccess.ReadWrite; } if ((fileMode == FileMode.Append) && (fileAccess == FileAccess.ReadWrite)) { // Note: .NET does not support the "a+" mode, use "r+" and Seek() fileMode = FileMode.OpenOrCreate; fileAccess = FileAccess.ReadWrite; accessOptions |= StreamAccessOptions.SeekEnd; } if (mode.IndexOf('b') > -1) { // flags |= O_BINARY; forceBinary = true; } if (mode.IndexOf('t') > -1) { // flags |= _O_TEXT; forceText = true; } // Exactly one of these options is required. if ((forceBinary && forceText) || (!forceBinary && !forceText)) { //LocalConfiguration config = Configuration.Local; //// checks whether default mode is applicable: //if (config.FileSystem.DefaultFileOpenMode == "b") //{ // forceBinary = true; //} //else if (config.FileSystem.DefaultFileOpenMode == "t") //{ // forceText = true; //} //else //{ // PhpException.Throw(PhpError.Warning, ErrResources.ambiguous_file_mode, mode); //} throw new NotImplementedException("Configuration.FileSystem.DefaultFileOpenMode"); // Binary mode is assumed } else if (forceText) { // Default mode is binary (unless the text mode is specified). accessOptions |= StreamAccessOptions.UseText; } // Store the two file-access flags into the access options too. accessOptions |= (StreamAccessOptions)fileAccess; return true; }