private void EditFileAsSingleString(FileData fileData)
{
using (var fileStream = new FileStream(fileData.Path, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
{
if (this.Encoding == null)
{
WriteVerboseEncodingInfo(fileData);
}
Encoding encoding = this.Encoding != null?EncodingConversion.Convert(this, Encoding, "Encoding") : fileData.Encoding;
var streamReader = new StreamReader(fileStream, encoding);
var content = streamReader.ReadToEnd();
for (int i = 0; i < _regexes.Length; i++)
{
content = _regexes[i].Replace(content, this.Replacement[i]);
}
streamReader.DiscardBufferedData();
fileStream.SetLength(0L);
var streamWriter = new StreamWriter(fileStream, encoding);
streamWriter.Write(content);
streamWriter.Flush();
}
}
protected override void BeginProcessing()
{
if (this.encoding != null)
{
this.textEncoding = EncodingConversion.Convert(this, this.encoding);
}
else
{
this.textEncoding = new UTF8Encoding();
}
if (!this.simpleMatch)
{
RegexOptions options = this.caseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase;
this.regexPattern = new Regex[this.pattern.Length];
for (int i = 0; i < this.pattern.Length; i++)
{
try
{
this.regexPattern[i] = new Regex(this.pattern[i], options);
}
catch (Exception exception)
{
base.ThrowTerminatingError(BuildErrorRecord(MatchStringStrings.InvalidRegex, this.pattern[i], exception.Message, "InvalidRegex", exception));
throw;
}
}
}
this.globalContextTracker = new ContextTracker(this.preContext, this.postContext);
}
/// <summary>
/// Copies data from the source stream to the target stream.
/// </summary>
/// <param name="source">Source stream</param>
/// <param name="target">Target stream</param>
/// <param name="encodingConversion">Text encoding conversion to apply when copying stream</param>
private static void CopyStream(Stream source, Stream target, EncodingConversion encodingConversion = EncodingConversion.None)
{
const int BUFFER_SIZE = 0x1000;
byte[] bufferRead = new byte[BUFFER_SIZE];
int size = 0;
while ((size = source.Read(bufferRead, 0, BUFFER_SIZE)) > 0)
{
var bufferToWrite = bufferRead;
// If requested, convert encoding.
if (encodingConversion == EncodingConversion.UTF16ToUTF8)
{
var unicode = new UnicodeEncoding(false, false);
var content = unicode.GetString(bufferRead, 0, size);
bufferToWrite = Encoding.UTF8.GetBytes(content);
size = bufferToWrite.Length;
}
else if (encodingConversion == EncodingConversion.UTF8ToUTF16)
{
var content = Encoding.UTF8.GetString(bufferRead, 0, size);
var unicode = new UnicodeEncoding(false, false);
bufferToWrite = unicode.GetBytes(content);
size = bufferToWrite.Length;
}
target.Write(bufferToWrite, 0, size);
}
}
public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
{
string str;
if (!LanguagePrimitives.TryConvertTo <string>(inputData, out str) || (((!string.Equals(str, "unknown", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "string", StringComparison.OrdinalIgnoreCase)) && (!string.Equals(str, "unicode", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "bigendianunicode", StringComparison.OrdinalIgnoreCase))) && (((!string.Equals(str, "utf8", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "utf7", StringComparison.OrdinalIgnoreCase)) && (!string.Equals(str, "utf32", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "ascii", StringComparison.OrdinalIgnoreCase))) && (!string.Equals(str, "default", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "oem", StringComparison.OrdinalIgnoreCase)))))
{
return(inputData);
}
return(EncodingConversion.Convert(null, str));
}
private void EditFileByLineImpl(FileData fileData, FileStream sourceFileStream, Stream editResultsStream)
{
if (this.Encoding == null)
{
WriteVerboseEncodingInfo(fileData);
}
Encoding writeEncoding = this.Encoding != null?EncodingConversion.Convert(this, Encoding, "Encoding") : fileData.Encoding;
var streamReader = new StreamReader(sourceFileStream);
var streamWriter = new StreamWriter(editResultsStream, writeEncoding);
string prevLine = null;
string line;
while ((line = streamReader.ReadLine()) != null)
{
if (prevLine != null)
{
streamWriter.WriteLine(prevLine);
}
prevLine = line;
for (int i = 0; i < _regexes.Length; i++)
{
prevLine = _regexes[i].Replace(prevLine, this.Replacement[i]);
}
}
// Use Write or WriteLine on last line depending on whether the source file ends in a newline.
if (fileData.LastLineEndsWithNewline)
{
streamWriter.WriteLine(prevLine ?? "");
}
else
{
streamWriter.Write(prevLine ?? "");
}
streamWriter.Flush();
// Resets results stream and source file stream to beginning to prep for copy operation.
streamReader.DiscardBufferedData();
sourceFileStream.SetLength(0L);
editResultsStream.Seek(0L, SeekOrigin.Begin);
editResultsStream.CopyTo(sourceFileStream);
sourceFileStream.Flush();
}
internal FileStreamBackReader(FileStream fileStream, Encoding encoding) : base(fileStream, encoding)
{
this._byteBuff = new byte[0x1000];
this._charBuff = new char[0x1000];
this._singleByteCharSet = null;
this._stream = fileStream;
if (this._stream.Length > 0L)
{
long position = this._stream.Position;
this._stream.Seek(0L, SeekOrigin.Begin);
base.Peek();
this._stream.Position = position;
this._currentEncoding = base.CurrentEncoding;
this._currentPosition = this._stream.Position;
this._oemEncoding = EncodingConversion.Convert(null, "oem");
this._defaultAnsiEncoding = EncodingConversion.Convert(null, "default");
}
}
internal StreamContentBackReader(Stream stream, Encoding encoding)
: base(stream, encoding)
{
_stream = stream;
if (_stream.Length > 0)
{
long curPosition = _stream.Position;
_stream.Seek(0, SeekOrigin.Begin);
base.Peek();
_stream.Position = curPosition;
_currentEncoding = base.CurrentEncoding;
_currentPosition = _stream.Position;
// Get the oem encoding and system current ANSI code page
_oemEncoding = EncodingConversion.Convert(null, EncodingConversion.OEM);
_defaultAnsiEncoding = EncodingConversion.Convert(null, EncodingConversion.Default);
}
}
public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
{
string encodingName;
if (LanguagePrimitives.TryConvertTo <string>(inputData, out encodingName))
{
if (string.Equals(encodingName, EncodingConversion.Unknown, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.String, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.Unicode, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.BigEndianUnicode, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.Utf8, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.Utf7, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.Utf32, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.Ascii, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.Default, StringComparison.OrdinalIgnoreCase) ||
string.Equals(encodingName, EncodingConversion.OEM, StringComparison.OrdinalIgnoreCase))
{
// the encodingName is guaranteed to be valid, so it is safe to pass null to method
// Convert(Cmdlet cmdlet, string encoding) as the value of 'cmdlet'.
return(EncodingConversion.Convert(null, encodingName));
}
}
return(inputData);
}
/// <summary>
/// Creates a byte array from the object passed to the cmdlet (based on type) and passes
/// that array on to the ConvertToHexidecimal method to output.
/// </summary>
/// <param name="inputObject"></param>
private void ProcessObjectContent(PSObject inputObject)
{
Object obj = inputObject.BaseObject;
byte[] inputBytes = null;
if (obj is System.IO.FileSystemInfo)
{
string[] path = { ((FileSystemInfo)obj).FullName };
List <string> pathsToProcess = ResolvePaths(path, true);
ProcessPath(pathsToProcess);
}
else if (obj is string)
{
string inputString = obj.ToString();
Encoding resolvedEncoding = EncodingConversion.Convert(this, Encoding);
inputBytes = resolvedEncoding.GetBytes(inputString);
}
else if (obj is byte)
{
inputBytes = new byte[] { (byte)obj };
}
else if (obj is byte[])
{
inputBytes = ((byte[])obj);
}
else if (obj is Int32)
{
inputBytes = BitConverter.GetBytes((Int32)obj);
}
else if (obj is Int32[])
{
List <byte> inputStreamArray = new List <byte>();
Int32[] inputInts = (Int32[])obj;
foreach (Int32 value in inputInts)
{
byte[] tempBytes = BitConverter.GetBytes(value);
inputStreamArray.AddRange(tempBytes);
}
inputBytes = inputStreamArray.ToArray();
}
else if (obj is Int64)
{
inputBytes = BitConverter.GetBytes((Int64)obj);
}
else if (obj is Int64[])
{
List <byte> inputStreamArray = new List <byte>();
Int64[] inputInts = (Int64[])obj;
foreach (Int64 value in inputInts)
{
byte[] tempBytes = BitConverter.GetBytes(value);
inputStreamArray.AddRange(tempBytes);
}
inputBytes = inputStreamArray.ToArray();
}
// If the object type is not supported, throw an error. Once Serialization is
// available on CoreCLR, other types will be supported.
else
{
string errorMessage = StringUtil.Format(UtilityCommonStrings.FormatHexTypeNotSupported, obj.GetType());
ErrorRecord errorRecord = new ErrorRecord(new ArgumentException(errorMessage),
"FormatHexTypeNotSupported",
ErrorCategory.InvalidArgument,
obj.GetType());
WriteError(errorRecord);
}
if (inputBytes != null)
{
ConvertToHexidecimal(inputBytes, null, 0);
}
}