public int GetScriptIndexFromPath(string scriptPath)
{
if (string.IsNullOrEmpty(scriptPath) != false)
{
return(-1);
}
int scriptIndex = 0;
foreach (IScriptObject script in loadedScripts)
{
IParsedScript parsed = script.GetParsedScript();
string path = (null == parsed ? null : parsed.GetScriptPath());
if (string.IsNullOrEmpty(path) == false)
{
StringComparison comparison = StringComparison.CurrentCultureIgnoreCase;
if (scriptPath.Equals(path, comparison))
{
return(scriptIndex); // Found the script!
}
}
scriptIndex = scriptIndex + 1;
}
return(-1);
}
private void AppendSearchPaths(ProtoCore.Options options)
{
string assemblyPath = Assembly.GetAssembly(typeof(ExecutionSession)).Location;
options.IncludeDirectories.Add(Path.GetDirectoryName(assemblyPath));
ITextEditorSettings editorSettings = TextEditorCore.Instance.TextEditorSettings;
if (Directory.Exists(editorSettings.IncludePath))
{
options.IncludeDirectories.Add(editorSettings.IncludePath);
}
IScriptObject entryPointScript = Solution.Current.ActiveScript;
if (null != entryPointScript)
{
IParsedScript parsedScript = entryPointScript.GetParsedScript();
if (null != parsedScript)
{
string scriptPath = parsedScript.GetScriptPath();
options.RootModulePathName = parsedScript.GetScriptPath();
if (string.IsNullOrEmpty(scriptPath) == false)
{
string directoryName = Path.GetDirectoryName(scriptPath);
options.IncludeDirectories.Add(directoryName);
}
}
}
}
public static List <string> GetSearchPaths()
{
List <string> includeDirectories = new List <string>();
string assemblyPath = Assembly.GetAssembly(typeof(ExtensionFactory)).Location;
includeDirectories.Add(Path.GetDirectoryName(assemblyPath));
if (Directory.Exists(textEditorCore.TextEditorSettings.IncludePath))
{
includeDirectories.Add(textEditorCore.TextEditorSettings.IncludePath);
}
IScriptObject entryPointScript = Solution.Current.ActiveScript;
if (null != entryPointScript)
{
IParsedScript parsedScript = entryPointScript.GetParsedScript();
if (null != parsedScript)
{
string scriptPath = parsedScript.GetScriptPath();
if (string.IsNullOrEmpty(scriptPath) == false)
{
string directoryName = Path.GetDirectoryName(scriptPath);
includeDirectories.Add(directoryName);
}
}
}
return(includeDirectories);
}
internal void DestroyScript()
{
if (null != this.parsedScript)
{
this.parsedScript.DestroyScript();
this.parsedScript = null;
}
}
public void CopyParsedResults(IParsedScript other)
{
if (null == other)
{
return;
}
this.codeBlockNode = other.GetParsedResults();
}
internal ScriptObject(IParsedScript parsedScript)
{
this.ScriptModifiedExternal = false;
this.parsedScript = parsedScript;
scriptState = new ScriptState(new TextBuffer(this));
if (null == this.parsedScript)
throw new InvalidOperationException("Invalid 'parsedScript'!");
InitializeFileWatcher(parsedScript.GetScriptPath());
}
public string GetScriptPathFromIndex(int index)
{
if (index < 0 || (index >= loadedScripts.Count))
{
return(string.Empty);
}
IParsedScript currentScript = loadedScripts[index].GetParsedScript();
return((null != currentScript) ? currentScript.GetScriptPath() : string.Empty);
}
internal ScriptObject(IParsedScript parsedScript)
{
this.ScriptModifiedExternal = false;
this.parsedScript = parsedScript;
scriptState = new ScriptState(new TextBuffer(this));
if (null == this.parsedScript)
{
throw new InvalidOperationException("Invalid 'parsedScript'!");
}
InitializeFileWatcher(parsedScript.GetScriptPath());
}
private void UpdateTabDisplayText()
{
IScriptObject currScript = Solution.Current.ActiveScript;
IParsedScript parsedScript = currScript.GetParsedScript();
if (null != parsedScript)
{
string filePath = parsedScript.GetScriptPath();
FileInfo fileInfo = new FileInfo(filePath);
int tabIndex = ScriptTabControl.CurrentTab;
ScriptTabControl.SetDisplayText(tabIndex, fileInfo.Name);
currScript.GetTextBuffer().ScriptModified = false;
}
}
private CodeFragmentManager CreateFromContent(string scriptContent)
{
MemoryStream inputStream = new MemoryStream(
Encoding.Default.GetBytes(scriptContent));
IParsedScript parsedScript = InterfaceFactory.CreateParsedScript();
if (parsedScript.ParseStream(inputStream))
{
return(new CodeFragmentManager(parsedScript));
}
return(null);
}
internal ScriptObject(string fileContent)
{
this.ScriptModifiedExternal = false;
this.parsedScript = InterfaceFactory.CreateParsedScript();
if (string.IsNullOrEmpty(fileContent) == false)
{
MemoryStream inputStream = new MemoryStream(
Encoding.Default.GetBytes(fileContent));
this.parsedScript.ParseStream(inputStream);
}
scriptState = new ScriptState(new TextBuffer(fileContent));
}
internal ScriptObject(string fileContent)
{
this.ScriptModifiedExternal = false;
this.parsedScript = InterfaceFactory.CreateParsedScript();
if (string.IsNullOrEmpty(fileContent) == false)
{
MemoryStream inputStream = new MemoryStream(
Encoding.Default.GetBytes(fileContent));
this.parsedScript.ParseStream(inputStream);
}
scriptState = new ScriptState(new TextBuffer(fileContent));
}
private void SerializeToScriptItems()
{
string directory = Path.GetDirectoryName(this.filePath);
if (directory.EndsWith("\\") == false)
{
directory += "\\";
}
Uri solutionPath = new Uri(directory, UriKind.Absolute);
List <ScriptItem> scripts = solutionData.Scripts;
scripts.Clear();
// Update each script path relative to the solution file.
foreach (IScriptObject scriptObject in loadedScripts)
{
IParsedScript parsedScript = scriptObject.GetParsedScript();
if (null != parsedScript)
{
try
{
Uri scriptPath = new Uri(parsedScript.GetScriptPath(), UriKind.Absolute);
Uri relativePath = solutionPath.MakeRelativeUri(scriptPath);
ScriptItem script = new ScriptItem();
script.RelativePath = relativePath.OriginalString;
script.EntryPoint = (activeScript == scriptObject);
scripts.Add(script);
}
catch (Exception exception)
{
// Invalid file path, deal with it.
string message = exception.Message;
}
}
}
// Update breakpoint path relative to the solution file.
foreach (BreakpointItem breakpoint in solutionData.Breakpoints)
{
Uri absolutePath = new Uri(breakpoint.AbsolutePath, UriKind.Absolute);
Uri relativePath = solutionPath.MakeRelativeUri(absolutePath);
breakpoint.RelativePath = relativePath.OriginalString;
}
}
internal CodeFragmentManager(IParsedScript iParsedScript)
{
// TODO: Complete member initialization
this.parsedScript = iParsedScript;
CodeBlockNode parsedResults = iParsedScript.GetParsedResults();
if (null != parsedResults)
{
NodeProcessor nodeProcessor = new NodeProcessor(parsedResults.Body);
nodeProcessor.GenerateFragments(out fragmentArray);
Array.Sort(fragmentArray);
}
else
{
// Create a dummy fragment just for the heck of it.
fragmentArray = new CodeFragment[] { new CodeFragment(-1, -1, -1) };
}
}
private string GetEntryScriptPath()
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
Logger.LogInfo("GetEntryScriptPath", "Init");
IParsedScript parsedScript = null;
IScriptObject entryPointScript = Solution.Current.ActiveScript;
if (null != entryPointScript)
{
parsedScript = entryPointScript.GetParsedScript();
}
string ret = (null == parsedScript ? null : parsedScript.GetScriptPath());
Logger.LogInfo("GetEntryScriptPath", ret);
Logger.LogPerf("GetEntryScriptPath", sw.ElapsedMilliseconds + " ms");
return(ret);
}
internal TextBuffer(IScriptObject owningScript)
{
this.owningScript = owningScript;
IParsedScript parsedScript = owningScript.GetParsedScript();
if (parsedScript.GetScriptPath() == "")
{
this.lineList = new List <string>();
this.lineList.Add(string.Empty);
}
else
{
string scriptFilePath = parsedScript.GetScriptPath();
ScriptFileReader scriptReader = new ScriptFileReader(scriptFilePath, true);
this.lineList = scriptReader.ReadInput();
}
undoRedoRecorder = new UndoRedoRecorder(this.lineList);
this.parsePending = true;
this.scriptModified = false;
}
protected bool FallsWithinActiveScript(CodePoint codePoint)
{
if (null == codePoint.SourceLocation || (null == currentScript))
{
return(false);
}
if (string.IsNullOrEmpty(codePoint.SourceLocation.FilePath))
{
throw new InvalidOperationException("'SourceLocation' not specified!");
}
IParsedScript parsedScript = currentScript.GetParsedScript();
if (null == parsedScript)
{
return(false);
}
string sourcePath = codePoint.SourceLocation.FilePath;
string activePath = parsedScript.GetScriptPath();
return(string.Compare(sourcePath, activePath, true) == 0);
}
internal IScriptObject OpenScript(string scriptPath)
{
solutionModified = true; // Changes should be persisted.
showSaveSolutionDialog = true;
if (File.Exists(scriptPath) == false)
{
return(null); // The file does not exist.
}
// If the entire script is so messed up that it cannot even be
// parsed in a meaningful way, then "ParseScript" call will fail.
// When that happens, we don't return "null" from here, the file
// open should continue (and errors be shown as red colored text).
IParsedScript parsedScript = InterfaceFactory.CreateParsedScript();
parsedScript.ParseScript(scriptPath);
// Add the new script to loaded scripts.
IScriptObject hostScript = new ScriptObject(parsedScript);
loadedScripts.Add(hostScript);
// Notify event subscribers that the script count has changed.
if (null != ScriptCountChanged)
{
ScriptCountChangedEventArgs eventArgs = new ScriptCountChangedEventArgs();
eventArgs.ScriptsAdded.Add(hostScript);
ScriptCountChanged(this, eventArgs);
}
// Subscribe to the new text buffer event notification.
ITextBuffer textBuffer = hostScript.GetTextBuffer();
textBuffer.LinesUpdated += linesUpdatedHandler;
return(hostScript);
}
internal void DestroyScript()
{
if (null != this.parsedScript)
{
this.parsedScript.DestroyScript();
this.parsedScript = null;
}
}
void OnMainWindowKeyDown(object sender, KeyEventArgs e)
{
IScriptObject activeScript = Solution.Current.ActiveScript;
if (null == activeScript)
{
return; // No active script.
}
IParsedScript parsedScript = activeScript.GetParsedScript();
if (null == parsedScript)
{
return; // No active script.
}
bool shift = Keyboard.IsKeyDown(Key.RightShift) || Keyboard.IsKeyDown(Key.LeftShift);
bool control = Keyboard.IsKeyDown(Key.RightCtrl) || Keyboard.IsKeyDown(Key.LeftCtrl);
bool capsLock = Console.CapsLock;
bool alt = Keyboard.IsKeyDown(Key.LeftAlt) || Keyboard.IsKeyDown(Key.RightAlt);
textCore.ReadOnlyState = IsDebuggingOrExecuting();
bool programRunning = textCore.ReadOnlyState;
parseTimer.Stop();
parseTimer.Start();
textCanvas.PauseCaretTimer(true);
textCanvas.PauseCaretTimer(false);
// Allow extensions to handle key event before allowing it to go into
// the text canvas. This way extensions can choose to filter or prevent
// a key from being processed.
//
if (null != editorExtensions)
{
foreach (EditorExtension extension in editorExtensions)
{
extension.PreKeyDownEvent(e);
if (e.Handled != false)
{
return;
}
}
}
e.Handled = true;
bool possibleLineChanges = false;
char character = char.MinValue;
switch (e.Key)
{
case Key.Delete:
case Key.Back:
if (!CheckExecutionState())
{
possibleLineChanges = true;
textCore.DoControlCharacter(e.Key);
}
break;
}
if (false == control) //control == false
{
switch (e.Key)
{
case Key.Space:
case Key.Tab:
if (!CheckExecutionState())
{
character = HandleCharacterKey(e);
}
break;
case Key.Enter:
if (!CheckExecutionState())
{
possibleLineChanges = true;
textCore.InsertText(GetKeyboardCharacter(e));
}
break;
default:
if ((e.Key >= Key.D0 && e.Key <= Key.Z) ||
(e.Key >= Key.NumPad0 && e.Key <= Key.Divide) ||
(e.Key >= Key.OemSemicolon && e.Key <= Key.Oem102))
{
if (!CheckExecutionState())
{
character = HandleCharacterKey(e);
}
}
break;
}
}
if (control == true && alt == true)
{
if ((e.Key >= Key.D0 && e.Key <= Key.Z) ||
(e.Key >= Key.NumPad0 && e.Key <= Key.Divide) ||
(e.Key >= Key.OemSemicolon && e.Key <= Key.Oem102))
{
if (!CheckExecutionState())
{
character = HandleCharacterKey(e);
}
}
}
if (false != possibleLineChanges)
{
UpdateCanvasDimension();
UpdateCaretPosition();
textCanvas.BreakpointsUpdated();
}
switch (e.Key)
{
case Key.Left:
case Key.Right:
case Key.Home:
case Key.End:
case Key.PageUp:
case Key.PageDown:
textCore.DoNavigation(e.Key);
break;
case Key.Up:
case Key.Down:
textCore.DoNavigation(e.Key);
break;
case Key.F9:
{
bool isInDebugMode = false;
if (textCore.ToggleBreakpoint())
{
textCanvas.BreakpointsUpdated();
}
else if (string.IsNullOrEmpty(activeScript.GetParsedScript().GetScriptPath()))
{
DisplayStatusMessage(StatusTypes.Warning, Configurations.SaveFileBreakpointWarning, 3);
}
else if (Solution.Current.ExecutionSession.IsExecutionActive(ref isInDebugMode))
{
DisplayStatusMessage(StatusTypes.Warning, Configurations.BreakpointDebugWarning, 3);
}
}
break;
}
if (null != editorExtensions)
{
// Allow extensions to process the key after it is processed.
foreach (EditorExtension extension in editorExtensions)
{
extension.PostKeyDownEvent(e, character);
}
}
// Some keys do not change the position of the cursor, for example
// CTRL and SHIFT keys. In such cases, the script doesn't need update.
if (IsCursorMovingKeyEvent(e))
{
UpdateCaretPosition();
UpdateUiForModifiedScript(Solution.Current.ActiveScript);
}
}
