protected override void ProcessRecord()
{
ProviderInfo providerInfo = null;
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
try
{
Collection <string> resolvedProviderPathFromPSPath = base.SessionState.Path.GetResolvedProviderPathFromPSPath(str, this.CmdletProviderContext, out providerInfo);
base.WriteObject(resolvedProviderPathFromPSPath, true);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
try
{
base.InvokeProvider.Property.New(str, this.Name, this.PropertyType, this.Value, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
try
{
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
cmdletProviderContext.PassThru = base.PassThru;
base.InvokeProvider.Property.Rename(this.path, this.Name, this.NewName, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
protected override void ProcessRecord()
{
string[] strArrays = this.paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
object[] objArray = new object[1];
objArray[0] = str;
CoreCommandBase.tracer.WriteLine("Invoking {0}", objArray);
try
{
base.InvokeProvider.Item.Invoke(str, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
try
{
PathInfo pathInfo = base.SessionState.Path.PopLocation(this.stackName);
if (this.PassThru)
{
base.WriteObject(pathInfo);
}
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (PSArgumentException pSArgumentException1)
{
PSArgumentException pSArgumentException = pSArgumentException1;
base.WriteError(new ErrorRecord(pSArgumentException.ErrorRecord, pSArgumentException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
protected override void ProcessRecord()
{
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
try
{
base.InvokeProvider.Property.Get(str, SessionStateUtilities.ConvertArrayToCollection <string>(this.property), this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
try
{
base.InvokeProvider.Property.Copy(str, this.property, this.Destination, this.property, base.GetCurrentContext());
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
private Collection <PathInfo> GetResolvedPaths(string path)
{
Collection <PathInfo> pathInfos = new Collection <PathInfo>();
try
{
pathInfos = base.SessionState.Path.GetResolvedPSPathFromPSPath(path);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
return(pathInfos);
}
protected override void ProcessRecord()
{
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
cmdletProviderContext.PassThru = false;
string[] path = base.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
try
{
base.InvokeProvider.Content.Clear(str, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
string[] strArrays = this.paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
try
{
base.InvokeProvider.Item.Get(str, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
Collection <PathInfo> resolvedPSPathFromPSPath;
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
resolvedPSPathFromPSPath = null;
try
{
resolvedPSPathFromPSPath = base.SessionState.Path.GetResolvedPSPathFromPSPath(str, this.CmdletProviderContext);
if (this.relative)
{
foreach (PathInfo pathInfo in resolvedPSPathFromPSPath)
{
string str1 = base.SessionState.Path.NormalizeRelativePath(pathInfo.Path, base.SessionState.Path.CurrentLocation.ProviderPath);
if (!str1.StartsWith(".", StringComparison.OrdinalIgnoreCase))
{
str1 = base.SessionState.Path.Combine(".", str1);
}
base.WriteObject(str1, false);
}
}
goto Label0;
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
return;
Label0:
if (!this.relative)
{
base.WriteObject(resolvedPSPathFromPSPath, true);
return;
}
else
{
return;
}
}
protected override void ProcessRecord()
{
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
cmdletProviderContext.PassThru = base.PassThru;
PSObject pSObject = null;
string parameterSetName = base.ParameterSetName;
string str = parameterSetName;
if (parameterSetName != null)
{
if (str == "propertyValuePathSet" || str == "propertyValueLiteralPathSet")
{
pSObject = new PSObject();
pSObject.Properties.Add(new PSNoteProperty(this.Name, this.Value));
}
else
{
if (str == "propertyPSObjectPathSet")
{
pSObject = this.InputObject;
}
}
}
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str1 = path[i];
try
{
base.InvokeProvider.Property.Set(str1, pSObject, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
if (this.paths == null || this.paths != null && (int)this.paths.Length == 0)
{
string[] empty = new string[1];
empty[0] = string.Empty;
this.paths = empty;
}
string[] strArrays = this.paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
string parameterSetName = base.ParameterSetName;
string str1 = parameterSetName;
if (parameterSetName != null && (str1 == "Items" || str1 == "LiteralItems"))
{
try
{
if (!this.Name)
{
base.InvokeProvider.ChildItem.Get(str, this.Recurse, cmdletProviderContext);
}
else
{
base.InvokeProvider.ChildItem.GetNames(str, ReturnContainers.ReturnMatchingContainers, this.Recurse, cmdletProviderContext);
}
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
}
internal List <ContentCommandBase.ContentHolder> GetContentReaders(string[] readerPaths, CmdletProviderContext currentCommandContext)
{
Collection <PathInfo> pathInfos = this.ResolvePaths(readerPaths, false, true, currentCommandContext);
List <ContentCommandBase.ContentHolder> contentHolders = new List <ContentCommandBase.ContentHolder>();
foreach (PathInfo pathInfo in pathInfos)
{
Collection <IContentReader> reader = null;
try
{
string path = WildcardPattern.Escape(pathInfo.Path);
if (currentCommandContext.SuppressWildcardExpansion)
{
path = pathInfo.Path;
}
reader = base.InvokeProvider.Content.GetReader(path, currentCommandContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
continue;
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
continue;
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
continue;
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
continue;
}
if (reader == null || reader.Count <= 0 || reader.Count != 1 || reader[0] == null)
{
continue;
}
ContentCommandBase.ContentHolder contentHolder = new ContentCommandBase.ContentHolder(pathInfo, reader[0], null);
contentHolders.Add(contentHolder);
}
return(contentHolders);
}
protected override void ProcessRecord()
{
CopyContainers copyContainer;
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
cmdletProviderContext.PassThru = this.PassThru;
string[] strArrays = this.paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
object[] destination = new object[2];
destination[0] = str;
destination[1] = this.Destination;
CoreCommandBase.tracer.WriteLine("Copy {0} to {1}", destination);
try
{
if (this.Container)
{
copyContainer = CopyContainers.CopyTargetContainer;
}
else
{
copyContainer = CopyContainers.CopyChildrenOfTargetContainer;
}
CopyContainers copyContainer1 = copyContainer;
base.InvokeProvider.Item.Copy(str, this.Destination, this.Recurse, copyContainer1, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
protected override void ProcessRecord()
{
string[] name = this.Name;
for (int i = 0; i < (int)name.Length; i++)
{
string str = name[i];
try
{
List <PSDriveInfo> matchingDrives = base.GetMatchingDrives(str, this.PSProvider, this.Scope);
if (matchingDrives.Count <= 0)
{
if (!WildcardPattern.ContainsWildcardCharacters(str))
{
DriveNotFoundException driveNotFoundException = new DriveNotFoundException(str, "DriveNotFound", SessionStateStrings.DriveNotFound);
base.WriteError(new ErrorRecord(driveNotFoundException, "GetDriveNoMatchingDrive", ErrorCategory.ObjectNotFound, str));
}
}
else
{
base.WriteObject(matchingDrives, true);
}
}
catch (DriveNotFoundException driveNotFoundException2)
{
DriveNotFoundException driveNotFoundException1 = driveNotFoundException2;
ErrorRecord errorRecord = new ErrorRecord(driveNotFoundException1, "GetLocationNoMatchingDrive", ErrorCategory.ObjectNotFound, str);
base.WriteError(errorRecord);
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
ErrorRecord errorRecord1 = new ErrorRecord(providerNotFoundException, "GetLocationNoMatchingDrive", ErrorCategory.ObjectNotFound, this.PSProvider);
base.WriteError(errorRecord1);
}
catch (PSArgumentOutOfRangeException pSArgumentOutOfRangeException1)
{
PSArgumentOutOfRangeException pSArgumentOutOfRangeException = pSArgumentOutOfRangeException1;
base.WriteError(new ErrorRecord(pSArgumentOutOfRangeException.ErrorRecord, pSArgumentOutOfRangeException));
}
catch (PSArgumentException pSArgumentException1)
{
PSArgumentException pSArgumentException = pSArgumentException1;
base.WriteError(new ErrorRecord(pSArgumentException.ErrorRecord, pSArgumentException));
}
}
}
internal List <ContentCommandBase.ContentHolder> GetContentWriters(string[] writerPaths, CmdletProviderContext currentCommandContext)
{
Collection <PathInfo> pathInfos = base.ResolvePaths(writerPaths, true, false, currentCommandContext);
List <ContentCommandBase.ContentHolder> contentHolders = new List <ContentCommandBase.ContentHolder>();
foreach (PathInfo pathInfo in pathInfos)
{
Collection <IContentWriter> writer = null;
try
{
writer = base.InvokeProvider.Content.GetWriter(pathInfo.Path, currentCommandContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
continue;
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
continue;
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
continue;
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
continue;
}
if (writer == null || writer.Count <= 0 || writer.Count != 1 || writer[0] == null)
{
continue;
}
ContentCommandBase.ContentHolder contentHolder = new ContentCommandBase.ContentHolder(pathInfo, null, writer[0]);
contentHolders.Add(contentHolder);
}
return(contentHolders);
}
protected override void ProcessRecord()
{
if (this.PSProvider == null || this.PSProvider != null && (int)this.PSProvider.Length == 0)
{
base.WriteObject(base.SessionState.Provider.GetAll(), true);
return;
}
else
{
string[] pSProvider = this.PSProvider;
for (int i = 0; i < (int)pSProvider.Length; i++)
{
string str = pSProvider[i];
PSSnapinQualifiedName instance = PSSnapinQualifiedName.GetInstance(str);
if (instance == null || !WildcardPattern.ContainsWildcardCharacters(instance.ShortName))
{
try
{
Collection <ProviderInfo> providerInfos = base.SessionState.Provider.Get(str);
base.WriteObject(providerInfos, true);
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
}
else
{
WildcardPattern wildcardPattern = new WildcardPattern(instance.ShortName, WildcardOptions.IgnoreCase);
foreach (ProviderInfo all in base.SessionState.Provider.GetAll())
{
if (!all.IsMatch(wildcardPattern, instance))
{
continue;
}
base.WriteObject(all);
}
}
}
return;
}
}
protected override void ProcessRecord()
{
if (this.paths == null || this.paths != null && (int)this.paths.Length == 0)
{
string[] empty = new string[1];
empty[0] = string.Empty;
this.paths = empty;
}
string[] strArrays = this.paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
try
{
base.InvokeProvider.Item.New(str, this.Name, this.ItemType, this.Value, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
internal override void BeforeOpenStreams(string[] paths)
{
if (paths == null || paths != null && (int)paths.Length == 0)
{
throw PSTraceSource.NewArgumentNullException("paths");
}
else
{
CmdletProviderContext cmdletProviderContext = new CmdletProviderContext(base.GetCurrentContext());
string[] strArrays = paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
try
{
base.InvokeProvider.Content.Clear(str, cmdletProviderContext);
cmdletProviderContext.ThrowFirstErrorOrDoNothing(true);
}
catch (PSNotSupportedException pSNotSupportedException)
{
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException)
{
}
}
return;
}
}
protected override void ProcessRecord()
{
CmdletProviderContext cmdletProviderContext;
Collection <PathInfo> resolvedPSPathFromPSPath;
StringCollection stringCollections = new StringCollection();
if (!this.resolve)
{
stringCollections.AddRange(this.Path);
}
else
{
cmdletProviderContext = this.CmdletProviderContext;
string[] strArrays = this.paths;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
resolvedPSPathFromPSPath = null;
try
{
resolvedPSPathFromPSPath = base.SessionState.Path.GetResolvedPSPathFromPSPath(str, cmdletProviderContext);
goto Label0;
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
}
Label3:
int num = 0;
while (num < stringCollections.Count)
{
string empty = null;
string parameterSetName = base.ParameterSetName;
string str1 = parameterSetName;
if (parameterSetName != null)
{
if (str1 == "IsAbsoluteSet")
{
string str2 = null;
bool flag = base.SessionState.Path.IsPSAbsolute(stringCollections[num], out str2);
base.WriteObject(flag);
goto Label1;
}
else if (str1 == "QualifierSet")
{
int num1 = stringCollections[num].IndexOf(":", StringComparison.CurrentCulture);
if (num1 >= 0)
{
if (!base.SessionState.Path.IsProviderQualified(stringCollections[num]))
{
empty = stringCollections[num].Substring(0, num1 + 1);
goto Label2;
}
else
{
empty = stringCollections[num].Substring(0, num1 + 2);
goto Label2;
}
}
else
{
FormatException formatException = new FormatException(StringUtil.Format(NavigationResources.ParsePathFormatError, stringCollections[num]));
base.WriteError(new ErrorRecord(formatException, "ParsePathFormatError", ErrorCategory.InvalidArgument, stringCollections[num]));
goto Label1;
}
}
else if (str1 == "ParentSet" || str1 == "LiteralPathSet")
{
if (!stringCollections[num].StartsWith("\\", StringComparison.CurrentCulture))
{
stringCollections[num].StartsWith("/", StringComparison.CurrentCulture);
}
try
{
empty = base.SessionState.Path.ParseParent(stringCollections[num], string.Empty, this.CmdletProviderContext, true);
goto Label2;
}
catch (PSNotSupportedException pSNotSupportedException2)
{
empty = string.Empty;
goto Label2;
}
}
else if (str1 == "LeafSet")
{
try
{
empty = base.SessionState.Path.ParseChildName(stringCollections[num], this.CmdletProviderContext, true);
goto Label2;
}
catch (PSNotSupportedException pSNotSupportedException3)
{
empty = stringCollections[num];
goto Label2;
}
catch (DriveNotFoundException driveNotFoundException3)
{
DriveNotFoundException driveNotFoundException2 = driveNotFoundException3;
base.WriteError(new ErrorRecord(driveNotFoundException2.ErrorRecord, driveNotFoundException2));
goto Label1;
}
catch (ProviderNotFoundException providerNotFoundException3)
{
ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3;
base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2));
goto Label1;
}
}
else if (str1 == "NoQualifierSet")
{
empty = this.RemoveQualifier(stringCollections[num]);
goto Label2;
}
}
Label2:
if (empty != null)
{
base.WriteObject(empty);
}
Label1:
num++;
}
return;
Label0:
IEnumerator <PathInfo> enumerator = resolvedPSPathFromPSPath.GetEnumerator();
using (enumerator)
{
while (enumerator.MoveNext())
{
PathInfo current = enumerator.Current;
try
{
if (base.InvokeProvider.Item.Exists(current.Path, cmdletProviderContext))
{
stringCollections.Add(current.Path);
}
}
catch (PSNotSupportedException pSNotSupportedException5)
{
PSNotSupportedException pSNotSupportedException4 = pSNotSupportedException5;
base.WriteError(new ErrorRecord(pSNotSupportedException4.ErrorRecord, pSNotSupportedException4));
}
catch (DriveNotFoundException driveNotFoundException5)
{
DriveNotFoundException driveNotFoundException4 = driveNotFoundException5;
base.WriteError(new ErrorRecord(driveNotFoundException4.ErrorRecord, driveNotFoundException4));
}
catch (ProviderNotFoundException providerNotFoundException5)
{
ProviderNotFoundException providerNotFoundException4 = providerNotFoundException5;
base.WriteError(new ErrorRecord(providerNotFoundException4.ErrorRecord, providerNotFoundException4));
}
catch (ItemNotFoundException itemNotFoundException3)
{
ItemNotFoundException itemNotFoundException2 = itemNotFoundException3;
base.WriteError(new ErrorRecord(itemNotFoundException2.ErrorRecord, itemNotFoundException2));
}
}
goto Label3;
}
}
protected override void ProcessRecord()
{
PathInfo pathInfo;
List <PSDriveInfo> matchingDrives;
string parameterSetName = base.ParameterSetName;
string str = parameterSetName;
if (parameterSetName != null)
{
if (str == "Location")
{
pathInfo = null;
if (this.PSDrive == null || (int)this.PSDrive.Length <= 0)
{
if ((this.PSDrive == null || (int)this.PSDrive.Length == 0) && this.PSProvider != null && (int)this.PSProvider.Length > 0)
{
string[] pSProvider = this.PSProvider;
for (int i = 0; i < (int)pSProvider.Length; i++)
{
string str1 = pSProvider[i];
bool flag = WildcardPattern.ContainsWildcardCharacters(str1);
if (!flag)
{
try
{
base.SessionState.Provider.GetOne(str1);
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
ErrorRecord errorRecord = new ErrorRecord(providerNotFoundException, "GetLocationNoMatchingProvider", ErrorCategory.ObjectNotFound, str1);
base.WriteError(errorRecord);
goto Label0;
}
}
foreach (ProviderInfo all in base.SessionState.Provider.GetAll())
{
if (!all.IsMatch(str1))
{
continue;
}
try
{
base.WriteObject(base.SessionState.Path.CurrentProviderLocation(all.FullName));
}
catch (ProviderNotFoundException providerNotFoundException3)
{
ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3;
base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
if (!flag)
{
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
}
}
Label0:
continue;
}
return;
}
else
{
base.WriteObject(base.SessionState.Path.CurrentLocation);
return;
}
}
else
{
string[] pSDrive = this.PSDrive;
for (int j = 0; j < (int)pSDrive.Length; j++)
{
string str2 = pSDrive[j];
matchingDrives = null;
try
{
matchingDrives = base.GetMatchingDrives(str2, this.PSProvider, null);
goto Label1;
}
catch (DriveNotFoundException driveNotFoundException3)
{
DriveNotFoundException driveNotFoundException2 = driveNotFoundException3;
ErrorRecord errorRecord1 = new ErrorRecord(driveNotFoundException2, "GetLocationNoMatchingDrive", ErrorCategory.ObjectNotFound, str2);
base.WriteError(errorRecord1);
}
catch (ProviderNotFoundException providerNotFoundException5)
{
ProviderNotFoundException providerNotFoundException4 = providerNotFoundException5;
ErrorRecord errorRecord2 = new ErrorRecord(providerNotFoundException4, "GetLocationNoMatchingProvider", ErrorCategory.ObjectNotFound, this.PSProvider);
base.WriteError(errorRecord2);
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
ErrorRecord errorRecord3 = new ErrorRecord(argumentException, "GetLocationNoMatchingDrive", ErrorCategory.ObjectNotFound, str2);
base.WriteError(errorRecord3);
}
}
return;
}
}
else
{
if (str == "Stack")
{
if (this.stackNames == null)
{
try
{
base.WriteObject(base.SessionState.Path.LocationStack(null), false);
}
catch (PSArgumentException pSArgumentException1)
{
PSArgumentException pSArgumentException = pSArgumentException1;
base.WriteError(new ErrorRecord(pSArgumentException.ErrorRecord, pSArgumentException));
}
}
else
{
string[] strArrays = this.stackNames;
for (int k = 0; k < (int)strArrays.Length; k++)
{
string str3 = strArrays[k];
try
{
base.WriteObject(base.SessionState.Path.LocationStack(str3), false);
}
catch (PSArgumentException pSArgumentException3)
{
PSArgumentException pSArgumentException2 = pSArgumentException3;
base.WriteError(new ErrorRecord(pSArgumentException2.ErrorRecord, pSArgumentException2));
}
}
return;
}
}
else
{
return;
}
}
}
return;
Label1:
List <PSDriveInfo> .Enumerator enumerator = matchingDrives.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
PSDriveInfo current = enumerator.Current;
try
{
string driveQualifiedPath = LocationGlobber.GetDriveQualifiedPath(current.CurrentLocation, current);
pathInfo = new PathInfo(current, current.Provider, driveQualifiedPath, base.SessionState);
base.WriteObject(pathInfo);
}
catch (ProviderNotFoundException providerNotFoundException7)
{
ProviderNotFoundException providerNotFoundException6 = providerNotFoundException7;
base.WriteError(new ErrorRecord(providerNotFoundException6.ErrorRecord, providerNotFoundException6));
}
}
return;
}
finally
{
enumerator.Dispose();
}
}
protected override void ProcessRecord()
{
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
try
{
if (!base.InvokeProvider.Item.Exists(this.Path, cmdletProviderContext))
{
object[] path = new object[1];
path[0] = this.Path;
PSInvalidOperationException pSInvalidOperationException = PSTraceSource.NewInvalidOperationException("NavigationResources", "RenameItemDoesntExist", path);
base.WriteError(new ErrorRecord(pSInvalidOperationException.ErrorRecord, pSInvalidOperationException));
return;
}
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
return;
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
return;
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
return;
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
return;
}
bool flag = false;
try
{
flag = base.SessionState.Path.IsCurrentLocationOrAncestor(this.path, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException3)
{
PSNotSupportedException pSNotSupportedException2 = pSNotSupportedException3;
base.WriteError(new ErrorRecord(pSNotSupportedException2.ErrorRecord, pSNotSupportedException2));
return;
}
catch (DriveNotFoundException driveNotFoundException3)
{
DriveNotFoundException driveNotFoundException2 = driveNotFoundException3;
base.WriteError(new ErrorRecord(driveNotFoundException2.ErrorRecord, driveNotFoundException2));
return;
}
catch (ProviderNotFoundException providerNotFoundException3)
{
ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3;
base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2));
return;
}
catch (ItemNotFoundException itemNotFoundException3)
{
ItemNotFoundException itemNotFoundException2 = itemNotFoundException3;
base.WriteError(new ErrorRecord(itemNotFoundException2.ErrorRecord, itemNotFoundException2));
return;
}
if (!flag)
{
cmdletProviderContext.PassThru = this.PassThru;
object[] newName = new object[2];
newName[0] = this.Path;
newName[1] = this.NewName;
CoreCommandBase.tracer.WriteLine("Rename {0} to {1}", newName);
try
{
base.InvokeProvider.Item.Rename(this.Path, this.NewName, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException5)
{
PSNotSupportedException pSNotSupportedException4 = pSNotSupportedException5;
base.WriteError(new ErrorRecord(pSNotSupportedException4.ErrorRecord, pSNotSupportedException4));
return;
}
catch (DriveNotFoundException driveNotFoundException5)
{
DriveNotFoundException driveNotFoundException4 = driveNotFoundException5;
base.WriteError(new ErrorRecord(driveNotFoundException4.ErrorRecord, driveNotFoundException4));
return;
}
catch (ProviderNotFoundException providerNotFoundException5)
{
ProviderNotFoundException providerNotFoundException4 = providerNotFoundException5;
base.WriteError(new ErrorRecord(providerNotFoundException4.ErrorRecord, providerNotFoundException4));
return;
}
catch (ItemNotFoundException itemNotFoundException5)
{
ItemNotFoundException itemNotFoundException4 = itemNotFoundException5;
base.WriteError(new ErrorRecord(itemNotFoundException4.ErrorRecord, itemNotFoundException4));
return;
}
return;
}
else
{
object[] objArray = new object[1];
objArray[0] = this.Path;
PSInvalidOperationException pSInvalidOperationException1 = PSTraceSource.NewInvalidOperationException("NavigationResources", "RenamedItemInUse", objArray);
base.WriteError(new ErrorRecord(pSInvalidOperationException1.ErrorRecord, pSInvalidOperationException1));
}
}
protected override void ProcessRecord()
{
ProviderInfo singleProvider = null;
try
{
singleProvider = base.SessionState.Internal.GetSingleProvider(this.PSProvider);
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
return;
}
if (singleProvider != null)
{
string newDriveConfirmAction = NavigationResources.NewDriveConfirmAction;
string newDriveConfirmResourceTemplate = NavigationResources.NewDriveConfirmResourceTemplate;
object[] name = new object[3];
name[0] = this.Name;
name[1] = singleProvider.FullName;
name[2] = this.Root;
string str = string.Format(Thread.CurrentThread.CurrentCulture, newDriveConfirmResourceTemplate, name);
if (base.ShouldProcess(str, newDriveConfirmAction))
{
if (this.Persist && !singleProvider.Name.Equals("FileSystem", StringComparison.OrdinalIgnoreCase))
{
ErrorRecord errorRecord = new ErrorRecord(new NotSupportedException(FileSystemProviderStrings.PersistNotSupported), "DriveRootNotNetworkPath", ErrorCategory.InvalidArgument, this);
base.ThrowTerminatingError(errorRecord);
}
PSDriveInfo pSDriveInfo = new PSDriveInfo(this.Name, singleProvider, this.Root, this.Description, base.Credential, this.Persist);
try
{
base.SessionState.Drive.New(pSDriveInfo, this.Scope, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException3)
{
ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3;
base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2));
}
catch (PSArgumentException pSArgumentException1)
{
PSArgumentException pSArgumentException = pSArgumentException1;
base.WriteError(new ErrorRecord(pSArgumentException.ErrorRecord, pSArgumentException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
catch (SessionStateOverflowException sessionStateOverflowException)
{
throw;
}
catch (SessionStateException sessionStateException1)
{
SessionStateException sessionStateException = sessionStateException1;
base.WriteError(new ErrorRecord(sessionStateException.ErrorRecord, sessionStateException));
}
}
}
}
private void MoveItem(string path)
{
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
try
{
string str = path;
if (!base.SuppressWildcardExpansion)
{
str = WildcardPattern.Escape(path);
}
if (!base.InvokeProvider.Item.Exists(str, cmdletProviderContext))
{
object[] objArray = new object[1];
objArray[0] = path;
PSInvalidOperationException pSInvalidOperationException = PSTraceSource.NewInvalidOperationException("NavigationResources", "MoveItemDoesntExist", objArray);
base.WriteError(new ErrorRecord(pSInvalidOperationException.ErrorRecord, pSInvalidOperationException));
return;
}
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
return;
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
return;
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
return;
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
return;
}
bool flag = false;
try
{
flag = base.SessionState.Path.IsCurrentLocationOrAncestor(path, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException3)
{
PSNotSupportedException pSNotSupportedException2 = pSNotSupportedException3;
base.WriteError(new ErrorRecord(pSNotSupportedException2.ErrorRecord, pSNotSupportedException2));
return;
}
catch (DriveNotFoundException driveNotFoundException3)
{
DriveNotFoundException driveNotFoundException2 = driveNotFoundException3;
base.WriteError(new ErrorRecord(driveNotFoundException2.ErrorRecord, driveNotFoundException2));
return;
}
catch (ProviderNotFoundException providerNotFoundException3)
{
ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3;
base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2));
return;
}
catch (ItemNotFoundException itemNotFoundException3)
{
ItemNotFoundException itemNotFoundException2 = itemNotFoundException3;
base.WriteError(new ErrorRecord(itemNotFoundException2.ErrorRecord, itemNotFoundException2));
return;
}
if (!flag)
{
CmdletProviderContext passThru = cmdletProviderContext;
passThru.PassThru = this.PassThru;
object[] destination = new object[2];
destination[0] = path;
destination[1] = this.Destination;
CoreCommandBase.tracer.WriteLine("Moving {0} to {1}", destination);
try
{
string str1 = path;
if (!base.SuppressWildcardExpansion)
{
str1 = WildcardPattern.Escape(path);
}
base.InvokeProvider.Item.Move(str1, this.Destination, passThru);
}
catch (PSNotSupportedException pSNotSupportedException5)
{
PSNotSupportedException pSNotSupportedException4 = pSNotSupportedException5;
base.WriteError(new ErrorRecord(pSNotSupportedException4.ErrorRecord, pSNotSupportedException4));
}
catch (DriveNotFoundException driveNotFoundException5)
{
DriveNotFoundException driveNotFoundException4 = driveNotFoundException5;
base.WriteError(new ErrorRecord(driveNotFoundException4.ErrorRecord, driveNotFoundException4));
}
catch (ProviderNotFoundException providerNotFoundException5)
{
ProviderNotFoundException providerNotFoundException4 = providerNotFoundException5;
base.WriteError(new ErrorRecord(providerNotFoundException4.ErrorRecord, providerNotFoundException4));
}
catch (ItemNotFoundException itemNotFoundException5)
{
ItemNotFoundException itemNotFoundException4 = itemNotFoundException5;
base.WriteError(new ErrorRecord(itemNotFoundException4.ErrorRecord, itemNotFoundException4));
}
}
else
{
object[] objArray1 = new object[1];
objArray1[0] = path;
PSInvalidOperationException pSInvalidOperationException1 = PSTraceSource.NewInvalidOperationException("NavigationResources", "MoveItemInUse", objArray1);
base.WriteError(new ErrorRecord(pSInvalidOperationException1.ErrorRecord, pSInvalidOperationException1));
return;
}
}
protected override void ProcessRecord()
{
Collection <PathInfo> resolvedPSPathFromPSPath;
CmdletProviderContext cmdletProviderContext = this.CmdletProviderContext;
bool flag = false;
bool flag1 = false;
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
resolvedPSPathFromPSPath = null;
try
{
resolvedPSPathFromPSPath = base.SessionState.Path.GetResolvedPSPathFromPSPath(str, cmdletProviderContext);
goto Label0;
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
}
return;
Label0:
IEnumerator <PathInfo> enumerator = resolvedPSPathFromPSPath.GetEnumerator();
using (enumerator)
{
while (enumerator.MoveNext())
{
PathInfo current = enumerator.Current;
bool flag2 = false;
try
{
flag2 = base.SessionState.Path.IsCurrentLocationOrAncestor(current.Path, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException3)
{
PSNotSupportedException pSNotSupportedException2 = pSNotSupportedException3;
base.WriteError(new ErrorRecord(pSNotSupportedException2.ErrorRecord, pSNotSupportedException2));
continue;
}
catch (DriveNotFoundException driveNotFoundException3)
{
DriveNotFoundException driveNotFoundException2 = driveNotFoundException3;
base.WriteError(new ErrorRecord(driveNotFoundException2.ErrorRecord, driveNotFoundException2));
continue;
}
catch (ProviderNotFoundException providerNotFoundException3)
{
ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3;
base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2));
continue;
}
catch (ItemNotFoundException itemNotFoundException3)
{
ItemNotFoundException itemNotFoundException2 = itemNotFoundException3;
base.WriteError(new ErrorRecord(itemNotFoundException2.ErrorRecord, itemNotFoundException2));
continue;
}
if (!flag2)
{
bool flag3 = false;
string unresolvedProviderPathFromPSPath = base.GetUnresolvedProviderPathFromPSPath(current.Path);
try
{
flag3 = base.SessionState.Internal.HasChildItems(current.Provider.Name, unresolvedProviderPathFromPSPath, cmdletProviderContext);
cmdletProviderContext.ThrowFirstErrorOrDoNothing();
}
catch (PSNotSupportedException pSNotSupportedException5)
{
PSNotSupportedException pSNotSupportedException4 = pSNotSupportedException5;
base.WriteError(new ErrorRecord(pSNotSupportedException4.ErrorRecord, pSNotSupportedException4));
continue;
}
catch (DriveNotFoundException driveNotFoundException5)
{
DriveNotFoundException driveNotFoundException4 = driveNotFoundException5;
base.WriteError(new ErrorRecord(driveNotFoundException4.ErrorRecord, driveNotFoundException4));
continue;
}
catch (ProviderNotFoundException providerNotFoundException5)
{
ProviderNotFoundException providerNotFoundException4 = providerNotFoundException5;
base.WriteError(new ErrorRecord(providerNotFoundException4.ErrorRecord, providerNotFoundException4));
continue;
}
catch (ItemNotFoundException itemNotFoundException5)
{
ItemNotFoundException itemNotFoundException4 = itemNotFoundException5;
base.WriteError(new ErrorRecord(itemNotFoundException4.ErrorRecord, itemNotFoundException4));
continue;
}
if (!this.Recurse && flag3)
{
string str1 = StringUtil.Format(NavigationResources.RemoveItemWithChildren, current.Path);
if (!base.ShouldContinue(str1, null, ref flag, ref flag1))
{
continue;
}
}
try
{
base.SessionState.Internal.RemoveItem(current.Provider.Name, unresolvedProviderPathFromPSPath, this.Recurse, cmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException7)
{
PSNotSupportedException pSNotSupportedException6 = pSNotSupportedException7;
base.WriteError(new ErrorRecord(pSNotSupportedException6.ErrorRecord, pSNotSupportedException6));
}
catch (DriveNotFoundException driveNotFoundException7)
{
DriveNotFoundException driveNotFoundException6 = driveNotFoundException7;
base.WriteError(new ErrorRecord(driveNotFoundException6.ErrorRecord, driveNotFoundException6));
}
catch (ProviderNotFoundException providerNotFoundException7)
{
ProviderNotFoundException providerNotFoundException6 = providerNotFoundException7;
base.WriteError(new ErrorRecord(providerNotFoundException6.ErrorRecord, providerNotFoundException6));
}
catch (ItemNotFoundException itemNotFoundException7)
{
ItemNotFoundException itemNotFoundException6 = itemNotFoundException7;
base.WriteError(new ErrorRecord(itemNotFoundException6.ErrorRecord, itemNotFoundException6));
}
}
else
{
object[] objArray = new object[1];
objArray[0] = current.Path;
PSInvalidOperationException pSInvalidOperationException = PSTraceSource.NewInvalidOperationException("NavigationResources", "RemoveItemInUse", objArray);
base.WriteError(new ErrorRecord(pSInvalidOperationException.ErrorRecord, pSInvalidOperationException));
}
}
return;
}
}
protected override void ProcessRecord()
{
object obj = null;
string parameterSetName = base.ParameterSetName;
string str = parameterSetName;
if (parameterSetName != null)
{
if (str == "Path" || str == "LiteralPath")
{
try
{
obj = base.SessionState.Path.SetLocation(this.Path, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
}
catch (PSArgumentException pSArgumentException1)
{
PSArgumentException pSArgumentException = pSArgumentException1;
base.WriteError(new ErrorRecord(pSArgumentException.ErrorRecord, pSArgumentException));
}
}
else
{
if (str == "Stack")
{
try
{
obj = base.SessionState.Path.SetDefaultLocationStack(this.StackName);
}
catch (ItemNotFoundException itemNotFoundException3)
{
ItemNotFoundException itemNotFoundException2 = itemNotFoundException3;
base.WriteError(new ErrorRecord(itemNotFoundException2.ErrorRecord, itemNotFoundException2));
}
}
}
}
if (this.passThrough && obj != null)
{
base.WriteObject(obj);
}
}
internal Collection <PathInfo> ResolvePaths(string[] pathsToResolve, bool allowNonexistingPaths, bool allowEmptyResult, CmdletProviderContext currentCommandContext)
{
Collection <PathInfo> pathInfos = new Collection <PathInfo>();
string[] strArrays = pathsToResolve;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
bool flag = false;
bool flag1 = false;
ErrorRecord errorRecord = null;
try
{
Collection <PathInfo> resolvedPSPathFromPSPath = base.SessionState.Path.GetResolvedPSPathFromPSPath(str, currentCommandContext);
if (resolvedPSPathFromPSPath.Count == 0)
{
flag = true;
if (!currentCommandContext.SuppressWildcardExpansion)
{
flag1 = true;
}
}
foreach (PathInfo pathInfo in resolvedPSPathFromPSPath)
{
pathInfos.Add(pathInfo);
}
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
flag = true;
errorRecord = new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException);
}
if (flag)
{
if (!allowNonexistingPaths || flag1 || !currentCommandContext.SuppressWildcardExpansion && WildcardPattern.ContainsWildcardCharacters(str))
{
if (errorRecord == null)
{
string str1 = StringUtil.Format(NavigationResources.ItemNotFound, this.Path);
Exception exception = new Exception(str1);
errorRecord = new ErrorRecord(exception, "ItemNotFound", ErrorCategory.ObjectNotFound, this.Path);
}
base.WriteError(errorRecord);
}
else
{
ProviderInfo providerInfo = null;
PSDriveInfo pSDriveInfo = null;
string unresolvedProviderPathFromPSPath = base.SessionState.Path.GetUnresolvedProviderPathFromPSPath(str, currentCommandContext, out providerInfo, out pSDriveInfo);
PathInfo pathInfo1 = new PathInfo(pSDriveInfo, providerInfo, unresolvedProviderPathFromPSPath, base.SessionState);
pathInfos.Add(pathInfo1);
}
}
}
return(pathInfos);
}
protected override void ProcessRecord()
{
string[] path = this.Path;
for (int i = 0; i < (int)path.Length; i++)
{
string str = path[i];
string str1 = null;
try
{
str1 = base.SessionState.Path.Combine(str, this.ChildPath, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException1)
{
PSNotSupportedException pSNotSupportedException = pSNotSupportedException1;
base.WriteError(new ErrorRecord(pSNotSupportedException.ErrorRecord, pSNotSupportedException));
goto Label0;
}
catch (DriveNotFoundException driveNotFoundException1)
{
DriveNotFoundException driveNotFoundException = driveNotFoundException1;
base.WriteError(new ErrorRecord(driveNotFoundException.ErrorRecord, driveNotFoundException));
goto Label0;
}
catch (ProviderNotFoundException providerNotFoundException1)
{
ProviderNotFoundException providerNotFoundException = providerNotFoundException1;
base.WriteError(new ErrorRecord(providerNotFoundException.ErrorRecord, providerNotFoundException));
goto Label0;
}
catch (ItemNotFoundException itemNotFoundException1)
{
ItemNotFoundException itemNotFoundException = itemNotFoundException1;
base.WriteError(new ErrorRecord(itemNotFoundException.ErrorRecord, itemNotFoundException));
goto Label0;
}
if (!this.Resolve)
{
if (str1 != null)
{
base.WriteObject(str1);
}
}
else
{
Collection <PathInfo> resolvedPSPathFromPSPath = null;
try
{
resolvedPSPathFromPSPath = base.SessionState.Path.GetResolvedPSPathFromPSPath(str1, this.CmdletProviderContext);
}
catch (PSNotSupportedException pSNotSupportedException3)
{
PSNotSupportedException pSNotSupportedException2 = pSNotSupportedException3;
base.WriteError(new ErrorRecord(pSNotSupportedException2.ErrorRecord, pSNotSupportedException2));
goto Label0;
}
catch (DriveNotFoundException driveNotFoundException3)
{
DriveNotFoundException driveNotFoundException2 = driveNotFoundException3;
base.WriteError(new ErrorRecord(driveNotFoundException2.ErrorRecord, driveNotFoundException2));
goto Label0;
}
catch (ProviderNotFoundException providerNotFoundException3)
{
ProviderNotFoundException providerNotFoundException2 = providerNotFoundException3;
base.WriteError(new ErrorRecord(providerNotFoundException2.ErrorRecord, providerNotFoundException2));
goto Label0;
}
catch (ItemNotFoundException itemNotFoundException3)
{
ItemNotFoundException itemNotFoundException2 = itemNotFoundException3;
base.WriteError(new ErrorRecord(itemNotFoundException2.ErrorRecord, itemNotFoundException2));
goto Label0;
}
for (int j = 0; j < resolvedPSPathFromPSPath.Count; j++)
{
try
{
if (resolvedPSPathFromPSPath[j] != null)
{
base.WriteObject(resolvedPSPathFromPSPath[j].Path);
}
}
catch (PSNotSupportedException pSNotSupportedException5)
{
PSNotSupportedException pSNotSupportedException4 = pSNotSupportedException5;
base.WriteError(new ErrorRecord(pSNotSupportedException4.ErrorRecord, pSNotSupportedException4));
}
catch (DriveNotFoundException driveNotFoundException5)
{
DriveNotFoundException driveNotFoundException4 = driveNotFoundException5;
base.WriteError(new ErrorRecord(driveNotFoundException4.ErrorRecord, driveNotFoundException4));
}
catch (ProviderNotFoundException providerNotFoundException5)
{
ProviderNotFoundException providerNotFoundException4 = providerNotFoundException5;
base.WriteError(new ErrorRecord(providerNotFoundException4.ErrorRecord, providerNotFoundException4));
}
catch (ItemNotFoundException itemNotFoundException5)
{
ItemNotFoundException itemNotFoundException4 = itemNotFoundException5;
base.WriteError(new ErrorRecord(itemNotFoundException4.ErrorRecord, itemNotFoundException4));
}
}
}
Label0:
continue;
}
}
