public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
string alias = args.Current;
// no quoted aliases..
if (alias.StartsWith("\"") || alias.StartsWith("'"))
{
return(CommandResultCode.SyntaxError);
}
// unless we override an alias, moan, if this command already
// exists.
if (!Application.Commands.Aliases.HasAlias(alias) &&
Application.Commands.ContainsCommand(alias))
{
Error.WriteLine("cannot alias built-in command!");
return(CommandResultCode.ExecutionFailed);
}
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
String value = StripQuotes(args.Current); // rest of values.
Application.Commands.Aliases.AddAlias(alias, value);
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
ISettingsHandler handler = Application as ISettingsHandler;
if (handler == null)
{
Error.WriteLine("The application doesn't support settings.");
return(CommandResultCode.ExecutionFailed);
}
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
string varName = args.Current;
bool success = UnsetVariable(varName, handler.Settings);
while (args.MoveNext())
{
success |= UnsetVariable(args.Current, handler.Settings);
}
return(success ? CommandResultCode.Success : CommandResultCode.ExecutionFailed);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (!(Application is ISettingsHandler))
{
Error.WriteLine("The application doesn't support settings.");
return(CommandResultCode.ExecutionFailed);
}
ApplicationSettings settings = ((ISettingsHandler)Application).Settings;
int argc = args.Count;
if (argc < 2)
{
return(CommandResultCode.SyntaxError);
}
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
string varname = args.Current;
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
string value = args.Current;
if (value.StartsWith("\"") && value.EndsWith("\""))
{
value = value.Substring(1, value.Length - 2);
}
else if (value.StartsWith("\'") && value.EndsWith("\'"))
{
value = value.Substring(1, value.Length - 2);
}
settings.SetVariable(varname, value);
Out.WriteLine();
Out.WriteLine("variable {0} set to {1}", varname, value);
Out.WriteLine();
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
try {
string arg = args.Current;
if (arg.ToLower().Equals("off"))
{
CloseSpool();
}
else if (arg.Length > 0)
{
OpenSpool(arg);
}
else
{
return(CommandResultCode.SyntaxError);
}
} catch (Exception e) {
System.Console.Error.Write(e.StackTrace);
return(CommandResultCode.ExecutionFailed);
}
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
if (!(Application is IPluginHandler))
{
Error.WriteLine("The application doesn't support plug-ins.");
return(CommandResultCode.ExecutionFailed);
}
ApplicationPlugins plugins = ((IPluginHandler)Application).Plugins;
string pluginType = args.Current;
if (!plugins.HasPlugin(pluginType))
{
Application.Error.WriteLine("unknown plugin '" + pluginType + "'");
return(CommandResultCode.ExecutionFailed);
}
if (!plugins.Unregister(pluginType))
{
return(CommandResultCode.ExecutionFailed);
}
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
if (!(Application is IPluginHandler))
{
Error.WriteLine("The application doesn't support plug-ins.");
return(CommandResultCode.ExecutionFailed);
}
ApplicationPlugins plugins = ((IPluginHandler)Application).Plugins;
string pluginType = args.Current;
if (plugins.HasPlugin(pluginType))
{
Application.Error.WriteLine("plugin '" + pluginType + "' already loaded");
return(CommandResultCode.ExecutionFailed);
}
Command plugin;
try {
plugin = plugins.LoadPlugin(pluginType);
} catch (Exception e) {
Application.Error.WriteLine("couldn't load plugin: " + e.Message);
return(CommandResultCode.ExecutionFailed);
}
if (plugin != null)
{
plugins.Add(pluginType, plugin);
Out.Write("adding command: ");
Out.Write(plugin.Name);
string[] aliases = plugin.Aliases;
if (aliases.Length > 0)
{
Out.Write(" (");
for (int i = 0; i < aliases.Length; ++i)
{
Out.Write(aliases[i]);
if (i < aliases.Length - 1)
{
Out.Write(", ");
}
}
Out.Write(")");
}
Out.WriteLine();
}
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
IInformationProvider provider = Application as IInformationProvider;
if (provider == null)
{
Error.WriteLine("The current context does not support information.");
return(CommandResultCode.ExecutionFailed);
}
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
string infoName = args.Current;
if (!provider.IsInfoSupported(infoName))
{
Error.WriteLine("Information " + infoName + " is not supported by the current context.");
return(CommandResultCode.ExecutionFailed);
}
ColumnDesign[] columns = provider.GetColumns(infoName);
for (int i = 0; i < columns.Length; i++)
{
columns[i].ResetWidth();
}
TableRenderer renderer = new TableRenderer(columns, Out);
// TODO: make it configurable ...
renderer.EnableHeader = true;
renderer.EnableFooter = true;
IList <ColumnValue[]> values = provider.GetValues(infoName);
for (int i = 0; i < values.Count; i++)
{
ColumnValue[] rowValues = values[i];
renderer.AddRow(rowValues);
}
renderer.Flush();
renderer.CloseTable();
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
ISettingsHandler handler = Application as ISettingsHandler;
if (handler == null)
{
Error.WriteLine("The application doesn't support settings.");
return(CommandResultCode.ExecutionFailed);
}
if (args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
VarColumns[0].ResetWidth();
VarColumns[1].ResetWidth();
TableRenderer table = new TableRenderer(VarColumns, Out);
table.EnableHeader = true;
table.EnableFooter = true;
foreach (KeyValuePair <string, string> setting in handler.Settings)
{
if (setting.Key == ApplicationSettings.SpecialLastCommand)
{
continue;
}
ColumnValue[] row = new ColumnValue[4];
row[0] = new ColumnValue(setting.Key);
row[1] = new ColumnValue(setting.Value);
table.AddRow(row);
}
table.CloseTable();
Error.WriteLine();
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
PropertyRegistry properties = Properties;
if (properties == null)
{
Application.Error.WriteLine("the current context does not support properties.");
return(CommandResultCode.ExecutionFailed);
}
if (args.MoveNext())
{
string name = args.Current;
PropertyHolder holder = properties.GetProperty(name);
if (holder == null)
{
return(CommandResultCode.ExecutionFailed);
}
PrintDescription(name, holder, Application.Error);
return(CommandResultCode.Success);
}
ProperiesColumns[0].ResetWidth();
ProperiesColumns[1].ResetWidth();
TableRenderer table = new TableRenderer(ProperiesColumns, Application.Out);
foreach (KeyValuePair <string, PropertyHolder> entry in properties)
{
ColumnValue[] row = new ColumnValue[3];
PropertyHolder holder = entry.Value;
row[0] = new ColumnValue(entry.Key);
row[1] = new ColumnValue(holder.Value);
row[2] = new ColumnValue(holder.ShortDescription);
table.AddRow(row);
}
table.CloseTable();
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (args.Count != 1)
{
return(CommandResultCode.SyntaxError);
}
PropertyRegistry properties = Properties;
if (properties == null)
{
Application.Error.WriteLine("the current context does not support properties.");
return(CommandResultCode.ExecutionFailed);
}
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
String name = args.Current;
PropertyHolder holder = properties.GetProperty(name);
if (holder == null)
{
return(CommandResultCode.ExecutionFailed);
}
string defaultValue = holder.DefaultValue;
try {
properties.SetProperty(name, defaultValue);
} catch (Exception) {
Application.Error.WriteLine("setting to default '" + defaultValue + "' failed.");
return(CommandResultCode.ExecutionFailed);
}
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (!args.MoveNext())
{
return(CommandResultCode.SyntaxError);
}
string varname = args.Current;
string[] newArgs = new string[args.Count - 1];
while (args.MoveNext())
{
newArgs[args.CurrentIndex - 1] = args.Current;
}
string param = String.Join(" ", newArgs);
int pos = 0;
int paramLength = param.Length;
// skip whitespace after 'set'
while (pos < paramLength &&
Char.IsWhiteSpace(param[pos]))
{
++pos;
}
// skip non-whitespace after 'set ': variable name
while (pos < paramLength &&
!Char.IsWhiteSpace(param[pos]))
{
++pos;
}
// skip whitespace before vlue..
while (pos < paramLength &&
Char.IsWhiteSpace(param[pos]))
{
++pos;
}
String value = param.Substring(pos);
if (value.StartsWith("\"") && value.EndsWith("\""))
{
value = value.Substring(1, value.Length - 2);
}
else if (value.StartsWith("\'") && value.EndsWith("\'"))
{
value = value.Substring(1, value.Length - 2);
}
try {
PropertyRegistry properties = Properties;
if (properties == null)
{
throw new Exception("The current context doesn't support properties.");
}
properties.SetProperty(varname, value);
} catch (Exception e) {
Application.Error.WriteLine(e.Message);
return(CommandResultCode.ExecutionFailed);
}
return(CommandResultCode.Success);
}
public override CommandResultCode Execute(IExecutionContext context, CommandArguments args)
{
if (args.Count > 1)
{
return(CommandResultCode.SyntaxError);
}
string commandName = null;
if (args.MoveNext())
{
commandName = args.Current;
}
// nothing given: provide generic help.
Application.Error.WriteLine();
int maxPad = 0;
if (commandName == null)
{
ICollection <Command> commands = Application.Commands.RegisteredCommands;
// process the command groups first...
Dictionary <string, List <CommandHelp> > groups = new Dictionary <string, List <CommandHelp> >();
foreach (Command command in commands)
{
string groupName = command.GroupName;
if (groupName == null || groupName.Length == 0)
{
groupName = "commands";
}
List <CommandHelp> list;
if (!groups.TryGetValue(groupName, out list))
{
list = new List <CommandHelp>();
groups[groupName] = list;
}
CommandHelp commandHelp = new CommandHelp();
StringBuilder cmdPrint = new StringBuilder(" ");
string[] aliases = command.Aliases;
cmdPrint.Append(command.Name);
if (aliases != null && aliases.Length > 0)
{
cmdPrint.Append(" | ");
for (int i = 0; i < aliases.Length; i++)
{
if (i != 0)
{
cmdPrint.Append(" | ");
}
cmdPrint.Append(aliases[i]);
}
}
commandHelp.Name = cmdPrint.ToString();
string description = command.ShortDescription;
if (description == null)
{
// no description ... try to get the groups description...
}
commandHelp.Description = description;
maxPad = Math.Max(maxPad, cmdPrint.Length);
list.Add(commandHelp);
}
foreach (KeyValuePair <string, List <CommandHelp> > entry in groups)
{
string groupName = entry.Key;
Application.Error.Write(groupName);
Application.Error.Write(":");
Application.Error.WriteLine();
List <CommandHelp> commandList = entry.Value;
foreach (CommandHelp command in commandList)
{
Application.Error.Write(" ");
Application.Error.Write(command.Name);
if (command.Description != null)
{
for (int i = 0; i < maxPad - command.Name.Length; ++i)
{
Application.Error.Write(" ");
}
Application.Error.Write(" : ");
Application.Error.Write(command.Description);
}
Application.Error.WriteLine();
}
}
}
else
{
CommandDispatcher disp = Application.Commands;
string cmdString = disp.CompleteCommandName(commandName);
Command c = disp.GetCommand(cmdString);
if (c == null)
{
Application.Error.WriteLine("Help: unknown command '" + cmdString + "'");
Application.Error.WriteLine();
return(CommandResultCode.ExecutionFailed);
}
WriteDescription(c);
}
Application.Error.WriteLine();
return(CommandResultCode.Success);
}