/// <summary>
/// Copy constructor to support cloning
/// </summary>
/// <param name="history"></param>
private HistoryInfo(HistoryInfo history)
{
_id = history._id;
_pipelineId = history._pipelineId;
_cmdline = history._cmdline;
_status = history._status;
_startTime = history._startTime;
_endTime = history._endTime;
_cleared = history._cleared;
}
private long Add(HistoryInfo entry)
{
if (entry == null)
{
throw PSTraceSource.NewArgumentNullException("entry");
}
this._buffer[this.GetIndexForNewEntry()] = entry;
this._countEntriesAdded += 1L;
entry.SetId(this._countEntriesAdded);
this.IncrementCountOfEntriesInBuffer();
return this._countEntriesAdded;
}
internal long AddEntry(long pipelineId, string cmdline, PipelineState status, DateTime startTime, DateTime endTime, bool skipIfLocked)
{
long num;
if (!Monitor.TryEnter(this._syncRoot, skipIfLocked ? 0 : -1))
{
return -1L;
}
try
{
this.ReallocateBufferIfNeeded();
HistoryInfo entry = new HistoryInfo(pipelineId, cmdline, status, startTime, endTime);
num = this.Add(entry);
}
finally
{
Monitor.Exit(this._syncRoot);
}
return num;
}
internal HistoryInfo[] GetEntries(long id, long count, SwitchParameter newest)
{
using (History._trace.TraceMethod())
{
this.ReallocateBufferIfNeeded();
if (count < -1L)
{
throw History._trace.NewArgumentOutOfRangeException(nameof(count), (object)count);
}
if (newest.ToString() == null)
{
throw History._trace.NewArgumentNullException(nameof(newest));
}
if (count == -1L || count > this._countEntriesAdded || count > (long)this._countEntriesInBuffer)
{
count = (long)this._countEntriesInBuffer;
}
if (count == 0L || this._countEntriesInBuffer == 0)
{
return(new HistoryInfo[0]);
}
lock (this._syncRoot)
{
ArrayList arrayList = new ArrayList();
if (id > 0L)
{
long num1 = id;
if (!newest.IsPresent)
{
long num2 = num1 - count + 1L;
if (num2 < 1L)
{
num2 = 1L;
}
for (long id1 = num1; id1 >= num2 && num2 > 1L; --id1)
{
if (this._buffer[this.GetIndexFromId(id1)] != null && this._buffer[this.GetIndexFromId(id1)].Cleared)
{
--num2;
}
}
for (long id1 = num2; id1 <= num1; ++id1)
{
if (this._buffer[this.GetIndexFromId(id1)] != null && !this._buffer[this.GetIndexFromId(id1)].Cleared)
{
arrayList.Add((object)this._buffer[this.GetIndexFromId(id1)].Clone());
}
}
}
else
{
long num2 = num1 + count - 1L;
if (num2 >= this._countEntriesAdded)
{
num2 = this._countEntriesAdded;
}
for (long id1 = num1; id1 <= num2 && num2 < this._countEntriesAdded; ++id1)
{
if (this._buffer[this.GetIndexFromId(id1)] != null && this._buffer[this.GetIndexFromId(id1)].Cleared)
{
++num2;
}
}
for (long id1 = num2; id1 >= num1; --id1)
{
if (this._buffer[this.GetIndexFromId(id1)] != null && !this._buffer[this.GetIndexFromId(id1)].Cleared)
{
arrayList.Add((object)this._buffer[this.GetIndexFromId(id1)].Clone());
}
}
}
}
else
{
long num1 = 0;
if (this._capacity != 64)
{
num1 = this.SmallestIDinBuffer();
}
if (!newest.IsPresent)
{
long id1 = 1;
if (this._capacity != 64 && this._countEntriesAdded > (long)this._capacity)
{
id1 = num1;
}
long num2 = count - 1L;
while (num2 >= 0L && id1 <= this._countEntriesAdded)
{
if (this._buffer[this.GetIndexFromId(id1)].Cleared)
{
++id1;
}
else
{
arrayList.Add((object)this._buffer[this.GetIndexFromId(id1)].Clone());
--num2;
++id1;
}
}
}
else
{
long countEntriesAdded = this._countEntriesAdded;
long num2 = count - 1L;
while (num2 >= 0L && (this._capacity == 64 || this._countEntriesAdded <= (long)this._capacity || countEntriesAdded >= num1) && countEntriesAdded >= 1L)
{
if (this._buffer[this.GetIndexFromId(countEntriesAdded)].Cleared)
{
--countEntriesAdded;
}
else
{
arrayList.Add((object)this._buffer[this.GetIndexFromId(countEntriesAdded)].Clone());
--num2;
--countEntriesAdded;
}
}
}
}
HistoryInfo[] historyInfoArray = new HistoryInfo[arrayList.Count];
arrayList.CopyTo((Array)historyInfoArray);
return(historyInfoArray);
}
}
}
private void ReallocateBufferIfNeeded()
{
int historySize = this.GetHistorySize();
if (historySize != this._capacity)
{
HistoryInfo[] infoArray = new HistoryInfo[historySize];
int num2 = this._countEntriesInBuffer;
if (num2 < this._countEntriesAdded)
{
num2 = (int) this._countEntriesAdded;
}
if (this._countEntriesInBuffer > historySize)
{
num2 = historySize;
}
for (int i = num2; i > 0; i--)
{
long id = (this._countEntriesAdded - i) + 1L;
infoArray[GetIndexFromId(id, historySize)] = this._buffer[this.GetIndexFromId(id)];
}
this._countEntriesInBuffer = num2;
this._capacity = historySize;
this._buffer = infoArray;
}
}
/// <summary>
/// Invoke-history is replaced in history by the command it executed.
/// This replacement happens only if Invoke-History is single element
/// in the pipeline. If there are more than one element in pipeline
/// (ex A | Invoke-History 2 | B) then we cannot do this replacement.
/// </summary>
private void ReplaceHistoryString(HistoryInfo entry)
{
//Get the current pipeline
LocalPipeline pipeline = (LocalPipeline)((LocalRunspace)Context.CurrentRunspace).GetCurrentlyRunningPipeline();
if (pipeline.AddToHistory)
{
pipeline.HistoryString = entry.CommandLine;
}
}
internal void RemoveFromInvokeHistoryEntryList(HistoryInfo entry)
{
this._invokeHistoryIds.Remove(entry.Id);
}
internal static ArrayList GetSuggestion(HistoryInfo lastHistory, Object lastError, ArrayList errorList)
{
ArrayList returnSuggestions = new ArrayList();
PSModuleInfo invocationModule = new PSModuleInfo(true);
invocationModule.SessionState.PSVariable.Set("lastHistory", lastHistory);
invocationModule.SessionState.PSVariable.Set("lastError", lastError);
int initialErrorCount = 0;
// Go through all of the suggestions
foreach (Hashtable suggestion in s_suggestions)
{
initialErrorCount = errorList.Count;
// Make sure the rule is enabled
if (!LanguagePrimitives.IsTrue(suggestion["Enabled"]))
continue;
SuggestionMatchType matchType = (SuggestionMatchType)LanguagePrimitives.ConvertTo(
suggestion["MatchType"],
typeof(SuggestionMatchType),
CultureInfo.InvariantCulture);
// If this is a dynamic match, evaluate the ScriptBlock
if (matchType == SuggestionMatchType.Dynamic)
{
object result = null;
ScriptBlock evaluator = suggestion["Rule"] as ScriptBlock;
if (evaluator == null)
{
suggestion["Enabled"] = false;
throw new ArgumentException(
SuggestionStrings.RuleMustBeScriptBlock, "Rule");
}
try
{
result = invocationModule.Invoke(evaluator, null);
}
catch (Exception e)
{
// Catch-all OK. This is a third-party call-out.
CommandProcessorBase.CheckForSevereException(e);
suggestion["Enabled"] = false;
continue;
}
// If it returned results, evaluate its suggestion
if (LanguagePrimitives.IsTrue(result))
{
string suggestionText = GetSuggestionText(suggestion["Suggestion"], (object[])suggestion["SuggestionArgs"], invocationModule);
if (!String.IsNullOrEmpty(suggestionText))
{
string returnString = String.Format(
CultureInfo.CurrentCulture,
"Suggestion [{0},{1}]: {2}",
(int)suggestion["Id"],
(string)suggestion["Category"],
suggestionText);
returnSuggestions.Add(returnString);
}
}
}
else
{
string matchText = String.Empty;
// Otherwise, this is a Regex match against the
// command or error
if (matchType == SuggestionMatchType.Command)
{
matchText = lastHistory.CommandLine;
}
else if (matchType == SuggestionMatchType.Error)
{
if (lastError != null)
{
Exception lastException = lastError as Exception;
if (lastException != null)
{
matchText = lastException.Message;
}
else
{
matchText = lastError.ToString();
}
}
}
else
{
suggestion["Enabled"] = false;
throw new ArgumentException(
SuggestionStrings.InvalidMatchType,
"MatchType");
}
// If the text matches, evaluate the suggestion
if (Regex.IsMatch(matchText, (string)suggestion["Rule"], RegexOptions.IgnoreCase))
{
string suggestionText = GetSuggestionText(suggestion["Suggestion"], (object[])suggestion["SuggestionArgs"], invocationModule);
if (!String.IsNullOrEmpty(suggestionText))
{
string returnString = String.Format(
CultureInfo.CurrentCulture,
"Suggestion [{0},{1}]: {2}",
(int)suggestion["Id"],
(string)suggestion["Category"],
suggestionText);
returnSuggestions.Add(returnString);
}
}
}
// If the rule generated an error, disable it
if (errorList.Count != initialErrorCount)
{
suggestion["Enabled"] = false;
}
}
return returnSuggestions;
}
/// <summary>
/// Adds an entry to the buffer. If buffer is full, overwrites
/// oldest entry in the buffer
/// </summary>
/// <param name="entry"></param>
/// <returns>Returns id for the entry. This id should be used to fetch
/// the entry from the buffer</returns>
/// <remarks>Id starts from 1 and is incremented by 1 for each new entry</remarks>
private long Add(HistoryInfo entry)
{
if (entry == null)
{
throw PSTraceSource.NewArgumentNullException("entry");
}
_buffer[GetIndexForNewEntry()] = entry;
//Increment count of entries added so far
_countEntriesAdded++;
//Id of an entry in history is same as its number in history store.
entry.SetId(_countEntriesAdded);
//Increment count of entries in buffer by 1
IncrementCountOfEntriesInBuffer();
return _countEntriesAdded;
}
}// end function
/// <summary>
/// Get History Entries based on the WildCard Pattern value.
/// If passed 0, returns all the values, else return on the basis of count.
/// </summary>
/// <param name="wildcardpattern"></param>
/// <param name="count"></param>
/// <param name="newest"></param>
/// <returns></returns>
internal HistoryInfo[] GetEntries(WildcardPattern wildcardpattern, long count, SwitchParameter newest)
{
lock (_syncRoot)
{
if (count < -1)
{
throw PSTraceSource.NewArgumentOutOfRangeException("count", count);
}
if (newest.ToString() == null)
{
throw PSTraceSource.NewArgumentNullException("newest");
}
if (count > _countEntriesAdded || count == -1)
{
count = _countEntriesInBuffer;
}
List<HistoryInfo> cmdlist = new List<HistoryInfo>();
long SmallestID = 1;
//if buffersize is changes,Get the smallest entry that's not cleared in the buffer
if (_capacity != DefaultHistorySize)
SmallestID = SmallestIDinBuffer();
if (count != 0)
{
if (!newest.IsPresent)
{
long id = 1;
if (_capacity != DefaultHistorySize)
{
if (_countEntriesAdded > _capacity)
id = SmallestID;
}
for (long i = 0; i <= count - 1;)
{
if (id > _countEntriesAdded) break;
if (_buffer[GetIndexFromId(id)].Cleared == false && wildcardpattern.IsMatch(_buffer[GetIndexFromId(id)].CommandLine.Trim()))
{
cmdlist.Add(_buffer[GetIndexFromId(id)].Clone()); i++;
}
id++;
}
}
else
{
long id = _countEntriesAdded;
for (long i = 0; i <= count - 1;)
{
//if buffersize is changed,we have to loop from max entry to min entry thats not cleared
if (_capacity != DefaultHistorySize)
{
if (_countEntriesAdded > _capacity)
{
if (id < SmallestID)
break;
}
}
if (id < 1) break;
if (_buffer[GetIndexFromId(id)].Cleared == false && wildcardpattern.IsMatch(_buffer[GetIndexFromId(id)].CommandLine.Trim()))
{
cmdlist.Add(_buffer[GetIndexFromId(id)].Clone()); i++;
}
id--;
}
}
}
else
{
for (long i = 1; i <= _countEntriesAdded; i++)
{
if (_buffer[GetIndexFromId(i)].Cleared == false && wildcardpattern.IsMatch(_buffer[GetIndexFromId(i)].CommandLine.Trim()))
{
cmdlist.Add(_buffer[GetIndexFromId(i)].Clone());
}
}
}
HistoryInfo[] entries = new HistoryInfo[cmdlist.Count];
cmdlist.CopyTo(entries);
return entries;
}
}
/// <summary>
/// Get count HistoryEntries
/// </summary>
/// <param name="id"></param>
/// <param name="count"></param>
/// <param name="newest"></param>
/// <returns>history entries</returns>
internal HistoryInfo[] GetEntries(long id, long count, SwitchParameter newest)
{
ReallocateBufferIfNeeded();
if (count < -1)
{
throw PSTraceSource.NewArgumentOutOfRangeException("count", count);
}
if (newest.ToString() == null)
{
throw PSTraceSource.NewArgumentNullException("newest");
}
if (count == -1 || count > _countEntriesAdded || count > _countEntriesInBuffer)
count = _countEntriesInBuffer;
if (count == 0 || _countEntriesInBuffer == 0)
{
return Utils.EmptyArray<HistoryInfo>();
}
lock (_syncRoot)
{
//Using list instead of an array to store the entries.With array we are getting null values
//when the historybuffer size is changed
List<HistoryInfo> entriesList = new List<HistoryInfo>();
if (id > 0)
{
long firstId, baseId;
baseId = id;
//get id,count,newest values
if (!newest.IsPresent)
{
//get older entries
//Calculate the first id (i.e lowest id to fetch)
firstId = baseId - count + 1;
//If first id is less than the lowest id in history store,
//assign lowest id as first ID
if (firstId < 1)
{
firstId = 1;
}
for (long i = baseId; i >= firstId; --i)
{
if (firstId <= 1) break;
// if entry is null , continue the loop with the next entry
if (_buffer[GetIndexFromId(i)] == null) continue;
if (_buffer[GetIndexFromId(i)].Cleared == true)
{
// we have to clear count entries before an id, so if an entry is null,decrement
// first id as long as its is greater than the lowest entry in the buffer.
firstId--;
continue;
}
}
for (long i = firstId; i <= baseId; ++i)
{
//if an entry is null after being cleared by clear-history cmdlet,
//continue with the next entry
if (_buffer[GetIndexFromId(i)] == null || _buffer[GetIndexFromId(i)].Cleared == true)
continue;
entriesList.Add(_buffer[GetIndexFromId(i)].Clone());
}
}
else
{ //get latest entries
// first id becomes the id +count no of entries from the end of the buffer
firstId = baseId + count - 1;
// if first id is more than the no of entries in the buffer, first id will be the last entry in the buffer
if (firstId >= _countEntriesAdded)
{
firstId = _countEntriesAdded;
}
for (long i = baseId; i <= firstId; i++)
{
if (firstId >= _countEntriesAdded) break;
// if entry is null , continue the loop with the next entry
if (_buffer[GetIndexFromId(i)] == null) continue;
if (_buffer[GetIndexFromId(i)].Cleared == true)
{
// we have to clear count entries before an id, so if an entry is null,increment first id
firstId++;
continue;
}
}
for (long i = firstId; i >= baseId; --i)
{
//if an entry is null after being cleared by clear-history cmdlet,
//continue with the next entry
if (_buffer[GetIndexFromId(i)] == null || _buffer[GetIndexFromId(i)].Cleared == true)
continue;
entriesList.Add(_buffer[GetIndexFromId(i)].Clone());
}
}
}
else
{
//get entries for count,newest
long index, SmallestID = 0;
//if we change the defaulthistory size and when no of entries exceed the size, then
//we need to get the smallest entry in the buffer when we want to clear the oldest entry
//eg if size is 5 and then the entries can be 7,6,1,2,3
if (_capacity != DefaultHistorySize)
SmallestID = SmallestIDinBuffer();
if (!newest.IsPresent)
{
//get oldest count entries
index = 1;
if (_capacity != DefaultHistorySize)
{
if (_countEntriesAdded > _capacity)
index = SmallestID;
}
for (long i = count - 1; i >= 0;)
{
if (index > _countEntriesAdded) break;
if ((index <= 0 || GetIndexFromId(index) >= _buffer.Length) ||
(_buffer[GetIndexFromId(index)].Cleared == true))
{
index++; continue;
}
else
{
entriesList.Add(_buffer[GetIndexFromId(index)].Clone());
i--; index++;
}
}
}
else
{
index = _countEntriesAdded;//SmallestIDinBuffer
for (long i = count - 1; i >= 0;)
{
// if an entry is cleared continue to the next entry
if (_capacity != DefaultHistorySize)
{
if (_countEntriesAdded > _capacity)
{
if (index < SmallestID)
break;
}
}
if (index < 1) break;
if ((index <= 0 || GetIndexFromId(index) >= _buffer.Length) ||
(_buffer[GetIndexFromId(index)].Cleared == true))
{ index--; continue; }
else
{
//clone the entry from the history buffer
entriesList.Add(_buffer[GetIndexFromId(index)].Clone());
i--; index--;
}
}
}
}
HistoryInfo[] entries = new HistoryInfo[entriesList.Count];
entriesList.CopyTo(entries);
return entries;
}// end lock
}// end function
/// <summary>
/// Create a new history entry
/// </summary>
/// <param name="pipelineId"></param>
/// <param name="cmdline"></param>
/// <param name="status"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="skipIfLocked">If true, the entry will not be added when the history is locked</param>
/// <returns>id for the new created entry. Use this id to fetch the
/// entry. Returns -1 if the entry is not added</returns>
/// <remarks>This function is thread safe</remarks>
internal long AddEntry(long pipelineId, string cmdline, PipelineState status, DateTime startTime, DateTime endTime, bool skipIfLocked)
{
if (!System.Threading.Monitor.TryEnter(_syncRoot, skipIfLocked ? 0 : System.Threading.Timeout.Infinite))
{
return -1;
}
try
{
ReallocateBufferIfNeeded();
HistoryInfo entry = new HistoryInfo(pipelineId, cmdline, status, startTime, endTime);
return Add(entry);
}
finally
{
System.Threading.Monitor.Exit(_syncRoot);
}
}
/// <summary>
/// Constructs history store
/// </summary>
internal History(ExecutionContext context)
{
//Create history size variable. Add ValidateRangeAttribute to
//validate the range.
Collection<Attribute> attrs = new Collection<Attribute>();
attrs.Add(new ValidateRangeAttribute(1, (int)Int16.MaxValue));
PSVariable historySizeVar = new PSVariable(SpecialVariables.HistorySize, DefaultHistorySize, ScopedItemOptions.None, attrs);
historySizeVar.Description = SessionStateStrings.MaxHistoryCountDescription;
context.EngineSessionState.SetVariable(historySizeVar, false, CommandOrigin.Internal);
_capacity = DefaultHistorySize;
_buffer = new HistoryInfo[_capacity];
}
internal HistoryInfo[] GetEntries(
WildcardPattern wildcardpattern,
long count,
SwitchParameter newest)
{
using (History._trace.TraceMethod())
{
lock (this._syncRoot)
{
if (count < -1L)
{
throw History._trace.NewArgumentOutOfRangeException(nameof(count), (object)count);
}
if (newest.ToString() == null)
{
throw History._trace.NewArgumentNullException(nameof(newest));
}
if (count > this._countEntriesAdded || count == -1L)
{
count = (long)this._countEntriesInBuffer;
}
ArrayList arrayList = new ArrayList();
long num = 1;
if (this._capacity != 64)
{
num = this.SmallestIDinBuffer();
}
if (count != 0L)
{
if (!newest.IsPresent)
{
long id = 1;
if (this._capacity != 64 && this._countEntriesAdded > (long)this._capacity)
{
id = num;
}
for (long index = 0; index <= count - 1L && id <= this._countEntriesAdded; ++id)
{
if (!this._buffer[this.GetIndexFromId(id)].Cleared && wildcardpattern.IsMatch(this._buffer[this.GetIndexFromId(id)].CommandLine.Trim()))
{
arrayList.Add((object)this._buffer[this.GetIndexFromId(id)].Clone());
++index;
}
}
}
else
{
long countEntriesAdded = this._countEntriesAdded;
for (long index = 0; index <= count - 1L && (this._capacity == 64 || this._countEntriesAdded <= (long)this._capacity || countEntriesAdded >= num) && countEntriesAdded >= 1L; --countEntriesAdded)
{
if (!this._buffer[this.GetIndexFromId(countEntriesAdded)].Cleared && wildcardpattern.IsMatch(this._buffer[this.GetIndexFromId(countEntriesAdded)].CommandLine.Trim()))
{
arrayList.Add((object)this._buffer[this.GetIndexFromId(countEntriesAdded)].Clone());
++index;
}
}
}
}
else
{
for (long id = 1; id <= this._countEntriesAdded; ++id)
{
if (!this._buffer[this.GetIndexFromId(id)].Cleared && wildcardpattern.IsMatch(this._buffer[this.GetIndexFromId(id)].CommandLine.Trim()))
{
arrayList.Add((object)this._buffer[this.GetIndexFromId(id)].Clone());
}
}
}
HistoryInfo[] historyInfoArray = new HistoryInfo[arrayList.Count];
arrayList.CopyTo((Array)historyInfoArray);
return(historyInfoArray);
}
}
}
/// <summary>
/// Reallocates the buffer if history size changed
/// </summary>
private void ReallocateBufferIfNeeded()
{
//Get current value of histoysize variable
int historySize = GetHistorySize();
if (historySize == _capacity)
return;
HistoryInfo[] tempBuffer = new HistoryInfo[historySize];
//Calculate number of entries to copy in new buffer.
int numberOfEntries = _countEntriesInBuffer;
//when buffer size is changed,we have to consider the totalnumber of entries added
if (numberOfEntries < _countEntriesAdded)
numberOfEntries = (int)_countEntriesAdded;
if (_countEntriesInBuffer > historySize)
numberOfEntries = historySize;
for (int i = numberOfEntries; i > 0; --i)
{
long nextId = _countEntriesAdded - i + 1;
tempBuffer[GetIndexFromId(nextId, historySize)] = _buffer[GetIndexFromId(nextId)];
}
_countEntriesInBuffer = numberOfEntries;
_capacity = historySize;
_buffer = tempBuffer;
}
internal static ArrayList GetSuggestion(HistoryInfo lastHistory, object lastError, ArrayList errorList)
{
ArrayList list = new ArrayList();
PSModuleInfo invocationModule = new PSModuleInfo(true);
invocationModule.SessionState.PSVariable.Set("lastHistory", lastHistory);
invocationModule.SessionState.PSVariable.Set("lastError", lastError);
int count = 0;
foreach (Hashtable hashtable in suggestions)
{
count = errorList.Count;
if (LanguagePrimitives.IsTrue(hashtable["Enabled"]))
{
SuggestionMatchType type = (SuggestionMatchType) LanguagePrimitives.ConvertTo(hashtable["MatchType"], typeof(SuggestionMatchType), CultureInfo.InvariantCulture);
if (type == SuggestionMatchType.Dynamic)
{
object obj2 = null;
ScriptBlock sb = hashtable["Rule"] as ScriptBlock;
if (sb == null)
{
hashtable["Enabled"] = false;
throw new ArgumentException(SuggestionStrings.RuleMustBeScriptBlock, "Rule");
}
try
{
obj2 = invocationModule.Invoke(sb, null);
}
catch (Exception exception)
{
CommandProcessorBase.CheckForSevereException(exception);
hashtable["Enabled"] = false;
continue;
}
if (LanguagePrimitives.IsTrue(obj2))
{
string suggestionText = GetSuggestionText(hashtable["Suggestion"], invocationModule);
if (!string.IsNullOrEmpty(suggestionText))
{
string str2 = string.Format(Thread.CurrentThread.CurrentCulture, "Suggestion [{0},{1}]: {2}", new object[] { (int) hashtable["Id"], (string) hashtable["Category"], suggestionText });
list.Add(str2);
}
}
}
else
{
string input = string.Empty;
switch (type)
{
case SuggestionMatchType.Command:
input = lastHistory.CommandLine;
break;
case SuggestionMatchType.Error:
if (lastError != null)
{
Exception exception2 = lastError as Exception;
if (exception2 != null)
{
input = exception2.Message;
}
else
{
input = lastError.ToString();
}
}
break;
default:
hashtable["Enabled"] = false;
throw new ArgumentException(SuggestionStrings.InvalidMatchType, "MatchType");
}
if (Regex.IsMatch(input, (string) hashtable["Rule"], RegexOptions.IgnoreCase))
{
string str4 = GetSuggestionText(hashtable["Suggestion"], invocationModule);
if (!string.IsNullOrEmpty(str4))
{
string str5 = string.Format(Thread.CurrentThread.CurrentCulture, "Suggestion [{0},{1}]: {2}", new object[] { (int) hashtable["Id"], (string) hashtable["Category"], str4 });
list.Add(str5);
}
}
}
if (errorList.Count != count)
{
hashtable["Enabled"] = false;
}
}
}
return list;
}
internal HistoryInfo[] GetEntries(long id, long count, SwitchParameter newest)
{
this.ReallocateBufferIfNeeded();
if (count < -1L)
{
throw PSTraceSource.NewArgumentOutOfRangeException("count", count);
}
if (newest.ToString() == null)
{
throw PSTraceSource.NewArgumentNullException("newest");
}
if (((count == -1L) || (count > this._countEntriesAdded)) || (count > this._countEntriesInBuffer))
{
count = this._countEntriesInBuffer;
}
if ((count == 0L) || (this._countEntriesInBuffer == 0))
{
return new HistoryInfo[0];
}
lock (this._syncRoot)
{
ArrayList list = new ArrayList();
if (id > 0L)
{
long num;
long num2 = id;
if (!newest.IsPresent)
{
num = (num2 - count) + 1L;
if (num < 1L)
{
num = 1L;
}
for (long i = num2; i >= num; i -= 1L)
{
if (num <= 1L)
{
break;
}
if ((this._buffer[this.GetIndexFromId(i)] != null) && this._buffer[this.GetIndexFromId(i)].Cleared)
{
num -= 1L;
}
}
for (long j = num; j <= num2; j += 1L)
{
if ((this._buffer[this.GetIndexFromId(j)] != null) && !this._buffer[this.GetIndexFromId(j)].Cleared)
{
list.Add(this._buffer[this.GetIndexFromId(j)].Clone());
}
}
}
else
{
num = (num2 + count) - 1L;
if (num >= this._countEntriesAdded)
{
num = this._countEntriesAdded;
}
for (long k = num2; k <= num; k += 1L)
{
if (num >= this._countEntriesAdded)
{
break;
}
if ((this._buffer[this.GetIndexFromId(k)] != null) && this._buffer[this.GetIndexFromId(k)].Cleared)
{
num += 1L;
}
}
for (long m = num; m >= num2; m -= 1L)
{
if ((this._buffer[this.GetIndexFromId(m)] != null) && !this._buffer[this.GetIndexFromId(m)].Cleared)
{
list.Add(this._buffer[this.GetIndexFromId(m)].Clone());
}
}
}
}
else
{
long num7;
long num8 = 0L;
if (this._capacity != 0x1000)
{
num8 = this.SmallestIDinBuffer();
}
if (!newest.IsPresent)
{
num7 = 1L;
if ((this._capacity != 0x1000) && (this._countEntriesAdded > this._capacity))
{
num7 = num8;
}
long num9 = count - 1L;
while (num9 >= 0L)
{
if (num7 > this._countEntriesAdded)
{
break;
}
if (((num7 <= 0L) || (this.GetIndexFromId(num7) >= this._buffer.Length)) || this._buffer[this.GetIndexFromId(num7)].Cleared)
{
num7 += 1L;
}
else
{
list.Add(this._buffer[this.GetIndexFromId(num7)].Clone());
num9 -= 1L;
num7 += 1L;
}
}
}
else
{
num7 = this._countEntriesAdded;
long num10 = count - 1L;
while (num10 >= 0L)
{
if ((((this._capacity != 0x1000) && (this._countEntriesAdded > this._capacity)) && (num7 < num8)) || (num7 < 1L))
{
break;
}
if (((num7 <= 0L) || (this.GetIndexFromId(num7) >= this._buffer.Length)) || this._buffer[this.GetIndexFromId(num7)].Cleared)
{
num7 -= 1L;
}
else
{
list.Add(this._buffer[this.GetIndexFromId(num7)].Clone());
num10 -= 1L;
num7 -= 1L;
}
}
}
}
HistoryInfo[] array = new HistoryInfo[list.Count];
list.CopyTo(array);
return array;
}
}
internal bool PresentInInvokeHistoryEntryList(HistoryInfo entry)
{
return this._invokeHistoryIds.Contains(entry.Id);
}
internal HistoryInfo[] GetEntries(WildcardPattern wildcardpattern, long count, SwitchParameter newest)
{
lock (this._syncRoot)
{
if (count < -1L)
{
throw PSTraceSource.NewArgumentOutOfRangeException("count", count);
}
if (newest.ToString() == null)
{
throw PSTraceSource.NewArgumentNullException("newest");
}
if ((count > this._countEntriesAdded) || (count == -1L))
{
count = this._countEntriesInBuffer;
}
ArrayList list = new ArrayList();
long num = 1L;
if (this._capacity != 0x1000)
{
num = this.SmallestIDinBuffer();
}
if (count != 0L)
{
if (!newest.IsPresent)
{
long id = 1L;
if ((this._capacity != 0x1000) && (this._countEntriesAdded > this._capacity))
{
id = num;
}
long num3 = 0L;
while (num3 <= (count - 1L))
{
if (id > this._countEntriesAdded)
{
break;
}
if (!this._buffer[this.GetIndexFromId(id)].Cleared && wildcardpattern.IsMatch(this._buffer[this.GetIndexFromId(id)].CommandLine.Trim()))
{
list.Add(this._buffer[this.GetIndexFromId(id)].Clone());
num3 += 1L;
}
id += 1L;
}
}
else
{
long num4 = this._countEntriesAdded;
long num5 = 0L;
while (num5 <= (count - 1L))
{
if ((((this._capacity != 0x1000) && (this._countEntriesAdded > this._capacity)) && (num4 < num)) || (num4 < 1L))
{
break;
}
if (!this._buffer[this.GetIndexFromId(num4)].Cleared && wildcardpattern.IsMatch(this._buffer[this.GetIndexFromId(num4)].CommandLine.Trim()))
{
list.Add(this._buffer[this.GetIndexFromId(num4)].Clone());
num5 += 1L;
}
num4 -= 1L;
}
}
}
else
{
for (long i = 1L; i <= this._countEntriesAdded; i += 1L)
{
if (!this._buffer[this.GetIndexFromId(i)].Cleared && wildcardpattern.IsMatch(this._buffer[this.GetIndexFromId(i)].CommandLine.Trim()))
{
list.Add(this._buffer[this.GetIndexFromId(i)].Clone());
}
}
}
HistoryInfo[] array = new HistoryInfo[list.Count];
list.CopyTo(array);
return array;
}
}
internal void AddToInvokeHistoryEntryList(HistoryInfo entry)
{
this._invokeHistoryIds.Add(entry.Id);
}
private void ReplaceHistoryString(HistoryInfo entry)
{
LocalPipeline currentlyRunningPipeline = (LocalPipeline) ((LocalRunspace) base.Context.CurrentRunspace).GetCurrentlyRunningPipeline();
if (currentlyRunningPipeline.AddToHistory)
{
currentlyRunningPipeline.HistoryString = entry.CommandLine;
}
}
