public static unsafe int ExecuteGOACommand(IntPtr clientData, IntPtr interp, int objc, IntPtr *argv)
{
string command = TclAPI.GetCsString(argv[0]);
for (int i = 1; i < objc; i++)
{
command += " " + TclAPI.GetCsString(argv[i]);
}
command += ";";
CommandStringParser parser = new CommandStringParser(command);
foreach (string cmdstr in parser.Parse())
{
bool valid = parser.ParseCommand(cmdstr, true, out Command cmd, out string errorDescr);
if (valid)
{
CommandExecuter.Instance.Execute(cmd);
Objects.CommandStackManager.Instance.Execute();
if (Program.mainInterpreter.context != null)
{
Program.mainInterpreter.context.Invalidate();
}
}
else
{
MessageBox.Show("Could not parse command " + Environment.NewLine + cmdstr + Environment.NewLine + "Error: " + errorDescr, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(1);
}
}
return(0);
}
protected void UserDefinedAction(object sender, EventArgs e)
{
CommandStringParser parser = new CommandStringParser(Command);
bool cmdFound = false;
foreach (string subComd in parser.Parse())
{
cmdFound = true;
Command cmd = null;
string errorDescr;
bool valid = parser.ParseCommand(subComd, true, out cmd, out errorDescr);
if (valid)
{
CommandExecuter.Instance.Execute(cmd);
}
else
{
MessageBox.Show(errorDescr + " when parsing " + Command, "Error during command parsing", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
if (!cmdFound && !string.IsNullOrEmpty(Command))
{
MessageBox.Show("Could not extract a command from " + Command + ". Missing semicolon after the last command?", "No commands executed", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Start the shell and run until exit command
/// </summary>
public void Run()
{
Console.WriteLine("GoAhead shell mode. Enter your command:");
Console.Write(">");
string cmdString = "";
while (true)
{
ConsoleKeyInfo info = Console.ReadKey();
if (info.Key.Equals(ConsoleKey.Enter))
{
// clear command for command trace
Console.WriteLine("");
// remove trailing ;
cmdString = cmdString.Replace(";", "");
Command cmd;
string errorDescr;
CommandStringParser parser = new CommandStringParser(cmdString);
bool valid = parser.ParseCommand(cmdString, true, out cmd, out errorDescr);
if (valid)
{
CommandExecuter.Instance.Execute(cmd);
CommandStackManager.Instance.Execute();
// new line printed by CommandExecuter already
Console.Write(">");
cmdString = "";
}
else
{
Console.WriteLine(errorDescr);
Console.Write(">");
cmdString = "";
}
}
else if (info.Key.Equals(ConsoleKey.Backspace))
{
if (cmdString.Length > 0)
{
cmdString = cmdString.Substring(0, cmdString.Length - 1);
}
}
else if (info.Key.Equals(ConsoleKey.Escape))
{
Console.WriteLine("");
Console.Write(">");
cmdString = "";
}
else
{
cmdString += info.KeyChar;
//Console.Write(info.KeyChar);
}
}
}
private void UpdateParameters(string cmdTag)
{
// clear previous data
m_dataGrdArguments.Columns.Clear();
m_dataGrdArguments.Columns.Add("Name", "Name");
m_dataGrdArguments.Columns.Add("Value", "Value");
m_dataGrdArguments.Columns.Add("Type", "Type");
m_dataGrdArguments.Columns[0].ReadOnly = true;
// the user will edit this column
m_dataGrdArguments.Columns[1].ReadOnly = false;
m_dataGrdArguments.Columns[2].ReadOnly = true;
m_dataGrdArguments.Rows.Clear();
// clear action text, otherwise the previos text would remain in case the selected command provides no action
m_txtAction.Text = "";
Type type = CommandStringParser.GetAllCommandTypes().FirstOrDefault(t => t.Name.ToString().Equals(cmdTag));
if (type == null)
{
return;
}
// create instance to get default value
Command cmd = (Command)Activator.CreateInstance(type);
// do not show unpublished commands
if (!cmd.PublishCommand)
{
return;
}
// print command action to text box
m_txtAction.Text = cmd.GetCommandDescription();
// arguments
foreach (FieldInfo fi in type.GetFields())
{
foreach (object obj in fi.GetCustomAttributes(true).Where(o => o is Parameter))
{
Parameter pf = (Parameter)obj;
// skip e.g. Profile
if (pf.PrintParameter)
{
// argument name, default value, type
m_dataGrdArguments.Rows.Add(fi.Name, fi.GetValue(cmd), fi.FieldType.Name);
int index = m_dataGrdArguments.Rows.Count - 2;
if (index < m_dataGrdArguments.Rows.Count)
{
m_dataGrdArguments.Rows[index].Cells[0].ToolTipText = pf.Comment;
m_dataGrdArguments.Rows[index].Cells[1].ToolTipText = pf.Comment;
m_dataGrdArguments.Rows[index].Cells[2].ToolTipText = pf.Comment;
}
}
}
}
}
public void Parse_CommandString_ParsedCommandNameZeroArgs()
{
var parsedCommand = CommandStringParser.Parse("command");
Assert.That(parsedCommand, Is.Not.Null);
Assert.That(parsedCommand.Name, Is.EqualTo("command"));
Assert.That(parsedCommand.Arguments, Is.Empty);
}
public void Parse_CommandString_ParsedCommandNameCorrectArgs()
{
var parsedCommand = CommandStringParser.Parse("command Arg0 Arg1");
Assert.That(parsedCommand, Is.Not.Null);
Assert.That(parsedCommand.Name, Is.EqualTo("command"));
Assert.That(parsedCommand.Arguments, Is.EqualTo(new[] { "Arg0", "Arg1" }));
}
void handle(string commandMessage)
{
var msg = CommandMessage.New(commandMessage);
var command = new CommandStringParser().GetArgumentString(msg.Arguments.ToArray());
var fullCommand = msg.Command + " " + command;
handle(new MessageArgs(Guid.Empty, fullCommand.Trim()));
}
public void AddToCommandTrace(Command cmd)
{
CommandStringParser parser = new CommandStringParser("");
bool valid = parser.SplitCommand(cmd.ToString(), out string cmdTag, out string argumentPart);
int offset = m_txtCommandTrace.TextLength;
string cmdString = cmd.ToString() + Environment.NewLine;
// dump command
m_txtCommandTrace.AppendText(cmdString);
if (!valid)
{
return;
}
// color command name red
m_txtCommandTrace.Select(offset, offset + cmdTag.Length);
m_txtCommandTrace.SelectionColor = Color.Red;
// let offset point right behind the command
offset += cmdTag.Length;
// color argument names blue and argument values black
if (!string.IsNullOrEmpty(argumentPart))
{
foreach (NameValuePair nameValuePair in parser.GetNameValuePairs(argumentPart))
{
m_txtCommandTrace.Select(offset + nameValuePair.NameFrom, offset + nameValuePair.NameTo);
m_txtCommandTrace.SelectionColor = Color.Blue;
m_txtCommandTrace.Select(offset + nameValuePair.ValueFrom, offset + nameValuePair.ValueTo);
m_txtCommandTrace.SelectionColor = Color.Black;
}
}
m_txtCommandTrace.DeselectAll();
m_txtCommandTrace.ScrollToCaret();
return;
/*
* int index = 0;
* while (index < cmdString.Length && cmdString[index] != ' ' && cmdString[index] != ';')
* {
* index++;
* }
* this.m_txtCommandTrace.Select(offset, offset + index);
* this.m_txtCommandTrace.SelectionColor = Color.Red;
*
* this.m_txtCommandTrace.Select(offset + index, this.m_txtCommandTrace.TextLength);
* this.m_txtCommandTrace.SelectionColor = Color.Blue;
* this.m_txtCommandTrace.DeselectAll();
* this.m_txtCommandTrace.ScrollToCaret();*/
}
public void Run(int portNumber)
{
TcpListener serverSocket = new TcpListener(portNumber);
TcpClient clientSocket = default(TcpClient);
serverSocket.Start();
Console.WriteLine(">> GoAhead Command Server Started");
clientSocket = serverSocket.AcceptTcpClient();
CommandStringParser parser = new CommandStringParser("");
while ((true))
{
try
{
NetworkStream networkStream = clientSocket.GetStream();
byte[] bytesFrom = new byte[10025];
networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize);
string dataFromClient = Encoding.ASCII.GetString(bytesFrom);
dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf('$'));
string[] atoms = dataFromClient.Split(';');
foreach (string commandString in atoms.Where(s => !string.IsNullOrEmpty(s)))
{
string errorDescription = "";
Command cmd = null;
bool valid = parser.ParseCommand(commandString, true, out cmd, out errorDescription);
if (valid)
{
CommandExecuter.Instance.Execute(cmd);
byte[] sendBytes = Encoding.ASCII.GetBytes("result=" + cmd.OutputManager.GetOutput() + "$");
networkStream.Write(sendBytes, 0, sendBytes.Length);
networkStream.Flush();
}
else
{
byte[] sendBytes = Encoding.ASCII.GetBytes(errorDescription);
networkStream.Write(sendBytes, 0, sendBytes.Length);
networkStream.Flush();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
break;
}
}
clientSocket.Close();
serverSocket.Stop();
Console.ReadLine();
}
public void AddAlias(string aliasName, string commands)
{
bool nameConflict = CommandStringParser.GetAllCommandTypes().Where(t => t.Name.Equals(aliasName)).Any();
if (nameConflict)
{
throw new ArgumentException(aliasName + " is an invalid alias name as it overwrites an existing command name");
}
m_aliases[aliasName] = commands;
}
protected override void DoCommandAction()
{
FileStream fs = File.OpenRead(OverlayScript);
byte[] byteBuffer = new byte[fs.Length];
int length = Convert.ToInt32(fs.Length);
fs.Read(byteBuffer, 0, length);
fs.Close();
CommandExecuter.Instance.MuteCommandTrace = true;
CommandStringParser parser = new CommandStringParser(byteBuffer, length);
TextWriter sl = new StreamWriter(SearchLoad, false);
TextWriter fence = new StreamWriter(Fence, false);
foreach (string cmdString in parser.Parse())
{
Command resolvedCommand = null;
string errorDescr;
bool valid = parser.ParseCommand(cmdString, true, out resolvedCommand, out errorDescr);
if (resolvedCommand is Set)
{
CommandExecuter.Instance.Execute(resolvedCommand);
Set setCmd = (Set)resolvedCommand;
string value = setCmd.Value;
if (Objects.IdentifierManager.Instance.IsMatch(value, Objects.IdentifierManager.RegexTypes.CLB))
{
AddToSelectionLoc addCmd = new AddToSelectionLoc();
addCmd.Location = value;
fence.WriteLine(addCmd.ToString());
}
}
else if (resolvedCommand is PathSearchOnFPGA)
{
CommandExecuter.Instance.MuteCommandTrace = false;
PathSearchOnFPGA searchCmd = (PathSearchOnFPGA)resolvedCommand;
//String from
//this.OutputManager.WriteOutput(searchCmd.StartLocation + "." + searchCmd.StartPort + "-" + searchCmd.TargetLocation + "." + searchCmd.TargetPort);
sl.WriteLine(searchCmd.StartLocation + "." + searchCmd.StartPort + "-" + searchCmd.TargetLocation + "." + searchCmd.TargetPort);
}
else
{
}
}
sl.Close();
fence.Close();
}
public override void CommandTrace(Command cmd)
{
string output = cmd.ToString();
if (!CommandExecuter.Instance.ColorOutput)
{
Console.WriteLine(output);
}
else
{
int index = 0;
// print command name in red
Console.ForegroundColor = ConsoleColor.Red;
while (index < output.Length && output[index] != ' ' && output[index] != ';')
{
Console.Write(output[index]);
index++;
}
Console.ResetColor();
// print blank
Console.Write(output[index++]);
string argumentPart = cmd.ToString();
argumentPart = argumentPart.Substring(index, argumentPart.Length - index);
CommandStringParser parser = new CommandStringParser("");
foreach (NameValuePair nameValuePair in parser.GetNameValuePairs(argumentPart))
{
// next command starts
Console.ForegroundColor = ConsoleColor.Cyan;
for (int i = 0; i < nameValuePair.Name.Length; i++)
{
Console.Write(output[index++]);
}
Console.ResetColor();
Console.Write(output[index++]);
for (int i = 0; i < nameValuePair.Value.Length; i++)
{
Console.Write(output[index++]);
}
if (index < output.Length)
{
Console.Write(output[index++]);
}
}
Console.WriteLine("");
// restore console color for next output (after end of program)
Console.ResetColor();
return;
}
}
private void userSelect(MessageArgs message, Editor editor)
{
var state = new ConfigReader(_endpoint.Token).Get("oi.userselect.ui.fallback");
if (state == "disabled")
{
return;
}
_ctx.Post((s) =>
{
try {
var args = new CommandStringParser().Parse(message.Message).ToArray();
var items = new List <string>();
var keys = new List <string>();
foreach (var item in args[3].Split(new[] { ',' }))
{
var chunks = item.Split(new[] { "||" }, StringSplitOptions.None);
if (chunks.Length > 1)
{
keys.Add(chunks[0]);
items.Add(chunks[1]);
}
else
{
keys.Add(item);
items.Add(item);
}
}
var command = "user-selected";
if (message.Message.StartsWith("user-select-at-caret "))
{
command = "user-selected-at-caret";
}
var form = new UserSelectForm(items, keys, (item) => {
if (item != null)
{
_endpoint.PublishEvent(command + " '" + args[2] + "' '" + item + "'");
}
else
{
_endpoint.PublishEvent(command + " '" + args[2] + "' 'user-cancelled'");
}
editor.SetFocus();
});
form.Show(this);
setToForeground(form);
} catch {
}
}, null);
}
public void Execute(string[] arguments)
{
using (var instance = _codeEngineFactory.GetInstance(Environment.CurrentDirectory)) {
if (instance == null)
{
return;
}
var args = "";
if (arguments.Length == 1)
{
args = arguments[0];
}
else
{
args = new CommandStringParser().GetArgumentString(arguments);
}
run(instance, args);
}
}
private void ShowToolTipAfterTimerFired(object sender, EventArgs e)
{
if (StoredPreferences.Instance.ShowToolTips)
{
Point p = (Point)m_timer.Tag;
// only show a new tool tip, if the position changes
if (m_lastToolTipLocation.Equals(p))
{
return;
}
m_lastToolTipLocation = p;
int cmdIndex = GetCommandIndex(p);
if (cmdIndex == -1)
{
return;
}
int from = m_commandIndeces[cmdIndex].Item1;
int length = m_commandIndeces[cmdIndex].Item2 - m_commandIndeces[cmdIndex].Item1;
string commandString = m_txtCmds.Text.Substring(from, length);
Command cmd = null;
string errorDescription = "";
CommandStringParser parser = new CommandStringParser(commandString);
bool valid = parser.ParseCommand(commandString, false, out cmd, out errorDescription);
if (valid)
{
// print command action to text box
foreach (Attribute attr in Attribute.GetCustomAttributes(cmd.GetType()).Where(a => a is CommandDescription))
{
CommandDescription descr = (CommandDescription)attr;
string toolTip = descr.Description;
m_toolTip.Show(toolTip, this, p.X, p.Y + 20, 10000);
break;
}
}
}
}
private void CommandInterfaceCtrl_Load(object sender, EventArgs e)
{
m_cmdBoxCommands.Items.Clear();
foreach (Type t in CommandStringParser.GetAllCommandTypes())
{
bool publish = true;
foreach (Attribute attr in Attribute.GetCustomAttributes(t))
{
if (attr is CommandDescription)
{
CommandDescription descr = (CommandDescription)attr;
publish = descr.Publish;
}
}
if (!publish)
{
continue;
}
m_cmdBoxCommands.Items.Add(t.Name);
}
}
private void userInput(MessageArgs message, Editor editor)
{
Logger.Write("Getting state for userinput fallback");
var state = new ConfigReader(_endpoint.Token).Get("oi.userinput.ui.fallback");
Logger.Write("State is " + state);
if (state == "disabled")
{
return;
}
_ctx.Post((s) =>
{
Logger.Write("Launching user input form");
try {
var args = new CommandStringParser().Parse(message.Message).ToArray();
var defaultValue = "";
if (args.Length > 3)
{
defaultValue = args[3];
}
var form = new UserInputForm(defaultValue, (item) => {
if (item != null)
{
_endpoint.PublishEvent("user-inputted '" + args[2] + "' '" + item + "'");
}
else
{
_endpoint.PublishEvent("user-inputted '" + args[2] + "' 'user-cancelled'");
}
editor.SetFocus();
});
form.Show(this);
setToForeground(form);
} catch (Exception ex) {
Logger.Write(ex);
}
}, null);
}
/// <summary>
/// handle user cmds
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void m_txtInputTrace_KeyPress(object sender, KeyPressEventArgs e)
{
if (e.KeyChar == (char)Keys.Return)
{
try
{
CommandStringParser parser = new CommandStringParser(m_txtInput.Text);
foreach (string cmdString in parser.Parse())
{
Command cmd;
string errorDescr;
bool valid = parser.ParseCommand(cmdString, true, out cmd, out errorDescr);
if (valid)
{
CommandExecuter.Instance.Execute(cmd);
}
else
{
MessageBox.Show("Could not parse command " + Environment.NewLine + cmdString + Environment.NewLine + "Error: " + errorDescr, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// update shell
Objects.CommandStackManager.Instance.Execute();
if (Parent != null)
{
Parent.Invalidate();
}
}
}
catch (Exception error)
{
MessageBox.Show(error.Message, "Error", MessageBoxButtons.OK);
}
m_txtInput.Clear();
}
}
private void parseLine(string line)
{
var check = line
.Replace(" ", "")
.Replace("\t", "");
var space = line.IndexOf("=");
if (check.StartsWith("//"))
{
return;
}
if (space == -1)
{
return;
}
space += 1;
if (check.StartsWith(DEFAULT_EDITOR_SETTING))
{
DefaultEditor = line.Substring(space, line.Length - space).Trim();
}
if (check.StartsWith(DEFAULT_LANGUAGE_SETTING))
{
DefaultLanguage = line.Substring(space, line.Length - space).Trim();
}
if (check.StartsWith(ENABLED_LANGUAGES_SETTING))
{
EnabledLanguages =
new CommandStringParser(',')
.Parse(line
.Substring(space, line.Length - space).Trim()).ToArray();
}
if (check.StartsWith("editor."))
{
_editorSettings.Add(check.Trim(new[] { ' ', '\t' }));
}
}
public string[] Parse(string[] args)
{
var newArgs = new List <string>();
foreach (var arg in args)
{
if (arg.StartsWith(DEFAULT_LANGUAGE))
{
DefaultLanguage = arg
.Substring(DEFAULT_LANGUAGE.Length, arg.Length - DEFAULT_LANGUAGE.Length);
continue;
}
else if (arg.StartsWith(ENABLED_LANGUAGES))
{
EnabledLanguages =
new CommandStringParser(',')
.Parse(arg
.Substring(
ENABLED_LANGUAGES.Length,
arg.Length - ENABLED_LANGUAGES.Length)).ToArray();
continue;
}
else if (arg == ENABLE_LOGGING)
{
LoggingEnabled = true;
continue;
}
else if (arg == RAW_OUTPUT)
{
RawOutput = true;
continue;
}
newArgs.Add(arg);
}
return(newArgs.ToArray());
}
public void Setup()
{
_parser = new CommandStringParser();
}
private void ReloadScript()
{
string scriptFile = m_lblScriptFiled.Text;
if (!File.Exists(scriptFile))
{
MessageBox.Show("Script file not found", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
m_txtCmds.Clear();
m_txtLineNumber.Clear();
m_commandIndeces.Clear();
m_commandIndex = 0;
m_form = 0;
m_length = 0;
m_lblCmd.Text = "No command selected";
// copy file into text box
StreamReader sr = new StreamReader(scriptFile);
string line = "";
int lineCount = 0;
while ((line = sr.ReadLine()) != null)
{
m_txtCmds.AppendText(line + Environment.NewLine);
m_txtLineNumber.AppendText((lineCount + 1).ToString() + Environment.NewLine);
lineCount++;
}
sr.Close();
m_context = new CommandExecutionContext();
CommandStringParser parser = new CommandStringParser(m_txtCmds.Text);
foreach (string cmdStr in parser.Parse())
{
Command cmd;
string errorDescr;
bool valid = parser.ParseCommand(cmdStr, false, out cmd, out errorDescr);
if (valid)
{
m_context.Parsed(cmdStr, cmd);
}
else
{
MessageBox.Show(errorDescr + Environment.NewLine + parser.State.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
m_context.SetLabels();
foreach (Tuple <int, int> range in parser.Topology.GetBorders(CommandStringTopology.TopologyType.Comment))
{
m_txtCmds.Select(range.Item1, (range.Item2 - range.Item1) + 1);
m_txtCmds.SelectionColor = Color.Green;
}
foreach (Tuple <int, int> range in parser.Topology.GetBorders(CommandStringTopology.TopologyType.CommandTag))
{
m_txtCmds.Select(range.Item1, (range.Item2 - range.Item1) + 1);
m_txtCmds.SelectionColor = Color.Red;
}
foreach (Tuple <int, int> range in parser.Topology.GetBorders(CommandStringTopology.TopologyType.ArgumentNames))
{
m_txtCmds.Select(range.Item1, (range.Item2 - range.Item1) + 1);
m_txtCmds.SelectionColor = Color.Blue;
}
foreach (Tuple <int, int> range in parser.Topology.GetBorders(CommandStringTopology.TopologyType.ArgumentValues))
{
m_txtCmds.Select(range.Item1, (range.Item2 - range.Item1) + 1);
m_txtCmds.SelectionColor = Color.Black;
}
foreach (Tuple <int, int> range in parser.Topology.GetBorders(CommandStringTopology.TopologyType.CompleteCommand))
{
m_commandIndeces.Add(new Tuple <int, int>(range.Item1, range.Item2));
}
SetSelectedItemToNextCommandListView();
}
public void Parse_NullCommandString_ArgumentNullException()
{
var ex = Assert.Throws <ArgumentNullException>(() => CommandStringParser.Parse(null));
Assert.That(ex.ParamName, Is.EqualTo(ParseCommandStringParam));
}
private void dispatchAndCompleteMessage(string command, Action onCommandCompleted)
{
Logger.Write("Dispatching " + command);
if (command.Length == 0)
{
Console.WriteLine();
}
else if (isError(command))
{
printError(command);
}
else if (isWarning(command))
{
printWarning(command);
}
else if (isColorized(command))
{
printColorized(command);
}
else if (isCommand(command) || isEvent(command))
{
lock (_commandProcessLock) {
_commandsInProcessing++;
}
ThreadPool.QueueUserWorkItem((m) => {
Logger.Write("Handling command in background thread");
if (isCommand(command))
{
Logger.Write("Handling as command");
var prefix = getCommandPrefix(command);
var parser = new CommandStringParser();
var args =
parser.Parse(
command.Substring(prefix.Length, command.Length - prefix.Length))
.ToArray();
if (args.Length == 0)
{
Logger.Write("No commands specified for " + command);
}
DefinitionCacheItem cmd = null;
if (prefix == "command|")
{
cmd = GetDefinitionBuilder().Get(args);
}
else if (prefix == "command-builtin|")
{
cmd = GetDefinitionBuilder().GetBuiltIn(args);
}
else if (prefix == "command-language|")
{
cmd = GetDefinitionBuilder().GetLanguage(args);
}
else if (prefix == "command-languagescript|")
{
cmd = GetDefinitionBuilder().GetLanguageScript(args);
}
else if (prefix == "command-script|")
{
cmd = GetDefinitionBuilder().GetScript(args);
}
else if (prefix == "command-original|")
{
cmd = GetDefinitionBuilder().GetOriginal(args);
}
if (cmd != null)
{
new CommandRunner(EventDispatcher)
.Run(cmd, args);
}
else
{
Logger.Write("Could not find handler for " + command);
}
onCommandCompleted();
}
else if (isEvent(command))
{
Logger.Write("Handling as event");
var prefix = "event|";
EventDispatcher()
.Forward(command.Substring(prefix.Length, command.Length - prefix.Length));
}
lock (_commandProcessLock) {
_commandsInProcessing--;
}
}, null);
}
else if (command.StartsWith("raw|"))
{
var msg = command.Substring(4, command.Length - 4);
Console.Write(msg);
}
else
{
Console.WriteLine(command);
}
}
private static bool handleOiLnk(ref string command, ref string arguments,
string workingDir,
Action <bool, string> onRecievedLine,
KeyValuePair <string, string>[] replacements)
{
if (Path.GetExtension(command) != ".oilnk")
{
return(false);
}
var fileDir = Path.GetDirectoryName(command);
var args = new CommandStringParser(' ').Parse(arguments);
var lnk = OiLnkReader.Read(File.ReadAllText(command));
if ((args.Count() == 2 && args.ElementAt(1) == "get-command-definitions") || (args.Count() == 1 && args.ElementAt(0) == "reactive-script-reacts-to"))
{
// Run preparer if exists
if (lnk.Preparer != null)
{
var preparerArgs = new CommandStringParser(' ').Parse(lnk.Preparer);
if (preparerArgs.Count() > 0)
{
var preparerFile = Path.Combine(fileDir, Path.GetFileNameWithoutExtension(command) + "-files", preparerArgs.ElementAt(0));
var preparerArguments = "";
if (preparerArgs.Count() > 1)
{
preparerArguments = new CommandStringParser(' ').GetArgumentString(preparerArgs.Skip(1).ToArray());
}
Logger.Write("Running preparer: " + preparerFile);
if (File.Exists(preparerFile))
{
string[] errors;
var output = new Process()
.QueryAll(preparerFile, preparerArguments, false, workingDir, out errors);
var hasErrors = false;
foreach (var line in output)
{
if (line.StartsWith("error|"))
{
onRecievedLine(true, line.Substring(6, line.Length - 6));
hasErrors = true;
}
}
foreach (var line in errors)
{
if (line.Trim().Length > 0)
{
onRecievedLine(true, line);
hasErrors = true;
}
}
if (hasErrors)
{
return(true);
}
}
}
}
else
{
Logger.Write("No preparer registered");
}
}
foreach (var handler in lnk.Handlers)
{
if (handler.Matches(args.ToArray()))
{
handler.WriteResponses((line) => onRecievedLine(false, line));
return(true);
}
}
if (lnk.LinkCommand == null)
{
return(true);
}
if (fileDir != null && File.Exists(Path.Combine(fileDir, lnk.LinkCommand)))
{
command = Path.Combine(fileDir, lnk.LinkCommand);
}
else if (File.Exists(Path.Combine(workingDir, lnk.LinkCommand)))
{
command = Path.Combine(workingDir, lnk.LinkCommand);
}
else
{
command = lnk.LinkCommand;
}
// This is a terrible hack, shame on me!!!!!!!
// If get command definitions don't mess with arguments
if (
(args.Count() == 2 && args.ElementAt(1) == "get-command-definitions") ||
(args.Count() == 1 && args.ElementAt(0) == "reactive-script-reacts-to")
)
{
return(false);
}
var originalArguments = arguments;
foreach (var replacement in replacements)
{
originalArguments = originalArguments.Replace(replacement.Key, "");
}
arguments =
lnk.LinkArguments
.Replace("{args}", originalArguments).Trim();
return(false);
}
static void Main(string[] args)
{
// TCL API init
//TclAPI.Initialize();
mainInterpreter = new TclInterpreter();
unsafe
{
ExecuteGOAcmd = TclProcs.ExecuteGOACommand;
TclDLL.Helper_RegisterProc(mainInterpreter.ptr, "cs", TclProcs.Cs);
TclDLL.Helper_RegisterProc(mainInterpreter.ptr, "cshelp", TclProcs.CsHelp);
TclDLL.Helper_RegisterProc(mainInterpreter.ptr, "cslist", TclProcs.CsList);
TclDLL.Helper_RegisterProc(mainInterpreter.ptr, "clear", TclProcs.Clear);
TclDLL.Helper_RegisterProc(mainInterpreter.ptr, "clearcontext", TclProcs.ClearContext);
//TclDLL.Helper_RegisterProc(mainInterpreter.ptr, "test", TclProcs.Test);
}
//int rc = mainInterpreter.EvalScript("puts [testproc Tile]");
//Console.WriteLine("rc=" + rc + " Interp.Result = " + mainInterpreter.Result);
// restore settings
StoredPreferences.LoadPrefernces();
// check vars
StringBuilder errorList;
if (!EnvChecker.CheckEnv(out errorList))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(errorList.ToString());
Console.ResetColor();
}
// detect commands without default constructor
foreach (Type type in CommandStringParser.GetAllCommandTypes())
{
try
{
Command cmd = (Command)Activator.CreateInstance(type);
TclDLL.Helper_RegisterProc(mainInterpreter.ptr, type.Name, ExecuteGOAcmd);
unsafe
{
//string[] parts = cmd.ToString().Split(' ');
//if (parts[0].EndsWith(";")) parts[0] = parts[0].Substring(0, parts[0].Length - 1);
TclDLL.Helper_RegisterProc(mainInterpreter.ptr, type.Name, ExecuteGOAcmd);
}
}
catch (Exception)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("Warning: No default constructor found for command " + type.Name);
Console.ResetColor();
}
}
// register console hook
// first hook print progress to clean the % output
CommandExecuter.Instance.AddHook(new PrintProgressToConsoleHook());
// the profiling hook must be added before the output hook hooks as it produces output
CommandExecuter.Instance.AddHook(new ProfilingHook());
CommandExecuter.Instance.AddHook(new ConsoleCommandHook());
CommandExecuter.Instance.AddHook(new PrintOutputHook());
// check if init.goa is found in binary of the current assembly
string dir = AssemblyDirectory;
string initFile = dir + Path.DirectorySeparatorChar + "init.goa";
// if so, execute init.goa
if (File.Exists(initFile))
{
RunScript runInitCmd = new RunScript();
runInitCmd.FileName = initFile;
CommandExecuter.Instance.Execute(runInitCmd);
//FileInfo fi = new FileInfo(initFile);
//CommandExecuter.Instance.Execute(fi);
}
else
{
Console.WriteLine("GoAhead did not find the init file: " + initFile);
}
bool showGUIOnly = false;
bool execScript = false;
string scriptFile = "";
bool shellMode = false;
bool serverMode = false;
int portNumber = 0;
bool commandMode = false;
if (args.Length == 0)
{
showGUIOnly = true;
}
else
{
int i = 0;
while (i < args.Length)
{
switch (args[i])
{
case "-gui":
showGUIOnly = true;
break;
case "-exec":
execScript = true;
scriptFile = GetScriptFileName(args, i + 1);
i++;
break;
case "-shell":
shellMode = true;
break;
case "-command":
case "-commands":
commandMode = true;
break;
case "-server":
portNumber = int.Parse(args[i + 1]);
i++;
break;
default:
if (args[i].EndsWith(".goa") && File.Exists(args[i]))
{
execScript = true;
scriptFile = GetScriptFileName(args, i);
}
break;
}
i++;
}
}
if (showGUIOnly)
{
// open gui
CommandExecuter.Instance.Execute(new Commands.GUI.ShowGUI());
}
else if (execScript)
{
if (!File.Exists(scriptFile))
{
string errorMessage = "Error: File " + scriptFile + " not found";
// allow the test scripts to catch this string (goahead -exec script.goa | tee.goa)
Console.WriteLine(errorMessage);
throw new ArgumentException(errorMessage);
}
// command file mode
FileInfo fi = new FileInfo(scriptFile);
CommandExecuter.Instance.Execute(fi);
}
else if (shellMode)
{
Objects.CommandShell shell = new Objects.CommandShell();
shell.Run();
}
else if (serverMode)
{
Objects.CommandServer server = new Objects.CommandServer();
server.Run(portNumber);
}
else if (commandMode)
{
string cmdString = "";
if (args.Length > 1)
{
for (int i = 1; i < args.Length; i++)
{
cmdString += args[i] + " ";
}
}
if (string.IsNullOrEmpty(cmdString))
{
Console.WriteLine("GoAhead was started with -commands, but no command was given");
}
Command cmd;
string errorDescr;
CommandStringParser parser = new CommandStringParser(cmdString);
foreach (string subCommandString in parser.Parse())
{
bool valid = parser.ParseCommand(subCommandString, true, out cmd, out errorDescr);
if (!valid)
{
Console.WriteLine(errorDescr);
}
CommandExecuter.Instance.Execute(cmd);
}
}
else
{
Console.WriteLine("No switch found. Start GoAhead with one of the following options:");
Console.WriteLine("GoAhead -gui : Open GoAhead in GUI-Mode");
Console.WriteLine("GoAhead -exec script.goa : Execute script.goa");
Console.WriteLine("GoAhead script.goa : Execute script.goa");
Console.WriteLine("GoAhead -shell : Start GoAhead shell (interactive Command mode)");
Console.WriteLine("GoAhead -command(s) : Execute GoAhead commands (e.g GoAhead -command \"FixS6XDLBug XDLInFile=in.xdl XDLOutFile=out.xdl;\"");
}
// save settings
StoredPreferences.SavePrefernces();
}
