protected string StSolution(IPM pm)
{
if (!pm.Is(LevelType.Property, "solution"))
{
throw new IncorrectNodeException(pm);
}
// solution.current.
if (pm.Is(1, LevelType.Property, "current"))
{
if (!env.IsOpenedSolution)
{
throw new NotSupportedOperationException("Property 'current' is not available. Open the Solution or use 'path()' method instead.");
}
return(StSlnPMap(env.SolutionFile, pm.PinTo(2)));
}
// solution.path("file").
if (pm.Is(1, LevelType.Method, "path"))
{
ILevel lvlPath = pm.Levels[1];
lvlPath.Is("solution.path(string sln)", ArgumentType.StringDouble);
return(StSlnPMap((string)lvlPath.Args[0].data, pm.PinTo(2)));
}
throw new IncorrectNodeException(pm, 1);
}
protected string DeleteFiles(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.Object))
{
return(DeleteFiles(pm.PinTo(1), (RArgs)level.Args[0].data));
}
if (level.Is(ArgumentType.Object, ArgumentType.Object))
{
return(DeleteFiles(pm.PinTo(1), (RArgs)level.Args[0].data, (RArgs)level.Args[1].data));
}
throw new PMLevelException(level, "delete.files(object files [, object except])");
}
protected string CopyDirectory(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean))
{
return(CopyDirectory(pm.PinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data));
}
if (level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean, ArgumentType.Boolean))
{
return(CopyDirectory(pm.PinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data, (bool)level.Args[3].data));
}
throw new PMLevelException(level, "copy.directory(string src, string dest, bool force [, bool overwrite])");
}
protected string DataClone(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.Integer))
{
return(DataClone(pm.PinTo(1), (string)level.Args[0].data, (int)level.Args[1].data));
}
if (level.Is(ArgumentType.StringDouble, ArgumentType.Integer, ArgumentType.Boolean))
{
return(DataClone(pm.PinTo(1), (string)level.Args[0].data, (int)level.Args[1].data, (bool)level.Args[2].data));
}
throw new PMLevelException(level, "data.clone(string name, integer count [, boolean forceEval])");
}
protected string stEvents(IPM pm)
{
if (!pm.Is(LevelType.Property, "events"))
{
throw new IncorrectNodeException(pm);
}
ILevel etype = pm.Levels[1];
if (etype.Type != LevelType.Property)
{
throw new IncorrectNodeException(pm, 1);
}
if (pm.Is(2, LevelType.Method, "item"))
{
SolutionEventType type;
try {
type = (SolutionEventType)Enum.Parse(typeof(SolutionEventType), etype.Data);
}
catch (ArgumentException) {
throw new OperandNotFoundException(etype.Data);
}
return(stEventItem(type, pm.PinTo(2)));
}
throw new IncorrectNodeException(pm, 2);
}
protected string stEventItem(SolutionEventType type, IPM pm)
{
ILevel level = pm.FirstLevel;
int index = -1;
ISolutionEvent evt;
if (level.Is(ArgumentType.StringDouble))
{
evt = getEventByName(type, (string)level.Args[0].data, out index);
}
else if (level.Is(ArgumentType.Integer))
{
index = (int)level.Args[0].data;
evt = getEventByIndex(type, index);
}
else
{
throw new PMLevelException(level, "`item( string name | integer index )`");
}
// .item(...).
if (pm.Is(1, LevelType.Property, "Enabled"))
{
return(pEnabled(evt, pm.PinTo(2)));
}
if (pm.Is(1, LevelType.Method, "run"))
{
return(mActionRun(type, evt, pm.PinTo(1)));
}
if (pm.Is(1, LevelType.Property, "Status"))
{
return(itemStatus(type, index, pm.PinTo(1)));
}
if (pm.Is(1, LevelType.Property, "stdout"))
{
return(pStdout(evt, pm.PinTo(2)));
}
if (pm.Is(1, LevelType.Property, "stderr"))
{
return(pStderr(evt, pm.PinTo(2)));
}
throw new IncorrectNodeException(pm, 1);
}
protected string DeleteDirectory(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.Boolean))
{
return(DeleteDirectory(pm.PinTo(1), (string)level.Args[0].data, (bool)level.Args[1].data));
}
throw new PMLevelException(level, "delete.directory(string dir, bool force)");
}
protected string DataGet(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.Boolean))
{
return(DataGet(pm.PinTo(1), (string)level.Args[0].data, (bool)level.Args[1].data));
}
throw new PMLevelException(level, "data.get(string name, boolean forceEval)");
}
protected string DataFree(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble))
{
return(DataFree(pm.PinTo(1), (string)level.Args[0].data));
}
throw new PMLevelException(level, "data.free(string name)");
}
protected string StSlnPMap(string sln, IPM pm)
{
if (string.IsNullOrWhiteSpace(sln))
{
throw new ArgumentException($"Failed {nameof(StSlnPMap)}: sln is empty");
}
ProjectsMap map = GetProjectsMap(sln);
if (pm.Is(LevelType.Property, "First"))
{
return(UseProjectsMap(map.FirstBy(env.IsCleanOperation), pm.PinTo(1)));
}
if (pm.Is(LevelType.Property, "Last"))
{
return(UseProjectsMap(map.LastBy(env.IsCleanOperation), pm.PinTo(1)));
}
if (pm.Is(LevelType.Property, "FirstRaw"))
{
return(UseProjectsMap(map.First, pm.PinTo(1)));
}
if (pm.Is(LevelType.Property, "LastRaw"))
{
return(UseProjectsMap(map.Last, pm.PinTo(1)));
}
if (pm.FinalEmptyIs(LevelType.Property, "GuidList"))
{
return(Value.From(map.GuidList));
}
if (pm.Is(LevelType.Method, "projectBy"))
{
ILevel lvlPrjBy = pm.FirstLevel;
lvlPrjBy.Is("projectBy(string guid)", ArgumentType.StringDouble);
return(UseProjectsMap(map.GetProjectBy((string)lvlPrjBy.Args[0].data), pm.PinTo(1)));
}
throw new IncorrectNodeException(pm);
}
protected string CopyFile(ILevel level, IPM pm)
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean))
{
return(CopyFile(pm.PinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data));
}
if (level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.Boolean, ArgumentType.Object))
{
return(CopyFile(pm.PinTo(1), (string)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data, (RArgs)level.Args[3].data));
}
if (level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Boolean))
{
return(CopyFile(pm.PinTo(1), (RArgs)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data));
}
if (level.Is(ArgumentType.Object, ArgumentType.StringDouble, ArgumentType.Boolean, ArgumentType.Object))
{
return(CopyFile(pm.PinTo(1), (RArgs)level.Args[0].data, (string)level.Args[1].data, (bool)level.Args[2].data, (RArgs)level.Args[3].data));
}
throw new PMLevelException(level, "copy.file((string src | object srclist), string dest, bool overwrite [, object except])");
}
protected string StProjectsFind(IPM pm)
{
ILevel level = pm.FirstLevel; // level of the `find` property
if (level.Is(ArgumentType.StringDouble))
{
string name = (string)level.Args[0].data;
return(ProjectCfg(name, pm.PinTo(1)));
}
throw new PMLevelException(level, "find(string name)");
}
protected string StItem(IPM pm)
{
if (!pm.Is(LevelType.Method, "item"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel; // level of the item() method
if (!level.Is(ArgumentType.StringDouble))
{
throw new PMLevelException(level, "item(string name)");
}
string name = (string)level.Args[0].data;
if (string.IsNullOrWhiteSpace(name)
/*|| name.Trim().Equals(Settings.OWP_ITEM_VSSBE, StringComparison.OrdinalIgnoreCase)*/)
{
throw new NotSupportedOperationException($"The OW pane '{name}' is not supported for current operation.");
}
pm.PinTo(1);
switch (pm.FirstLevel.Data)
{
case "write": {
return(StItemWrite(name, false, pm));
}
case "writeLine": {
return(StItemWrite(name, true, pm));
}
case "delete": {
return(StItemDelete(name, pm));
}
case "clear": {
return(StItemClear(name, pm));
}
case "activate": {
return(StItemActivate(name, pm));
}
}
throw new IncorrectNodeException(pm);
}
