b23f9c96d0
* Refactor language information classes * Implement SimpleLanguageInformation abstract class * Move some properties to SimpleLanguageInformation * Implement format and debug buttons disabling if Intellisense is not supported for current language * Add Intellisense available check in FormsExtensions to deactivate menu items if needed * Change function interfaces in VisibilityService * Replace CodeCompletionController.CurrentParser null checks with IntellisenseAvailable method call * Refactor IParser and BaseParser to deduplicate code * Fix BuildTreeInSpecialMode in SPythonParser * Add SimpleParser class for new languages without Intellisense * Delete duplicate SetDebugButtonsEnabled function * Add Intellisense available check in RunService when attaching debugger * Delete inner check in SetDebugButtonsEnabled to improve architecture * Change CurrentParser property in CodeCompletion to be CurrentLanguage * Divide ILanguageInformation into two interfaces (creating new ILanguageIntellisenseSupport) * Fix LanguageIntellisenseSupport initialization in BaseLanguage * Fix RunService fictive_attach logic * Disable Intellisense parsing for languages without Intellisense support * Add DefaultLanguageInformation abstract class * Add default implementation for SetSemanticConstants in BaseLanguage * Simplify IParser interface * Update developer guide documentation
574 lines
28 KiB
C#
574 lines
28 KiB
C#
// Copyright (c) Ivan Bondarev, Stanislav Mikhalkovich (for details please see \doc\copyright.txt)
|
||
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Text;
|
||
using System.Windows.Forms;
|
||
using System.IO;
|
||
using VisualPascalABCPlugins;
|
||
using System.Threading;
|
||
using Languages.Integration;
|
||
using Languages.Facade;
|
||
|
||
namespace VisualPascalABC
|
||
{
|
||
public class VECStringResources
|
||
{
|
||
public static string Get(string key)
|
||
{
|
||
return PascalABCCompiler.StringResources.Get("VP_VEC_"+key);
|
||
}
|
||
|
||
}
|
||
|
||
public class VisualEnvironmentCompiler: IVisualEnvironmentCompiler
|
||
{
|
||
PascalABCCompiler.CompilerType defaultCompilerType = PascalABCCompiler.CompilerType.Remote;
|
||
|
||
public static Encoding DefaultFileEncoding = Encoding.UTF8;
|
||
|
||
private IWorkbench workbench;
|
||
private PascalABCCompiler.RemoteCompiler remoteCompiler;
|
||
private PascalABCCompiler.Compiler standartCompiler;
|
||
private System.Threading.Thread MainProgramThread = System.Threading.Thread.CurrentThread;
|
||
private System.Threading.Thread StartingThread;
|
||
public delegate void SetFlagDelegate(bool flag);
|
||
private SetFlagDelegate SetCompilingAndRunButtonsEnabled;
|
||
private SetFlagDelegate SetDebugButtonsEnabled;
|
||
public ConvertTextDelegate ConvertUnitTextProperty { get; set; }
|
||
|
||
public delegate void SetTextDelegate(string text);
|
||
private SetTextDelegate SetStateText;
|
||
private SetTextDelegate AddTextToCompilerMessages;
|
||
private bool Compilation = false;
|
||
public VisualPascalABCPlugins.PluginsController PluginsController;
|
||
private ToolStripMenuItem PluginsMenuItem;
|
||
private ToolStrip PluginsToolStrip;
|
||
public bool compilerLoaded=false;
|
||
InvokeDegegate beginInvoke;
|
||
public InvokeDegegate BeginInvoke
|
||
{
|
||
get
|
||
{
|
||
return beginInvoke;
|
||
}
|
||
}
|
||
public delegate void ExecuteSourceLocationActionDelegate(PascalABCCompiler.SourceLocation SourceLocation, SourceLocationAction Action);
|
||
private ExecuteSourceLocationActionDelegate ExecuteSLAction;
|
||
public delegate object ExecuteVisualEnvironmentCompilerActionDelegate(VisualEnvironmentCompilerAction Action, object obj);
|
||
private ExecuteVisualEnvironmentCompilerActionDelegate ExecuteVECAction;
|
||
private bool StartingCompleted = false;
|
||
public PascalABCCompiler.Errors.ErrorsStrategyManager ErrorsManager;
|
||
private RunManager RunnerManager;
|
||
private DebugHelper DebugHelper;
|
||
private CodeCompletionParserController CodeCompletionParserController;
|
||
public UserOptions UserOptions;
|
||
private Dictionary<string, string> StandartDirectories;
|
||
Dictionary<string, CodeFileDocumentControl> OpenDocuments;
|
||
|
||
public VisualEnvironmentCompiler(InvokeDegegate beginInvoke,
|
||
SetFlagDelegate setCompilingAndRunButtonsEnabled, SetFlagDelegate setCompilingDebugEnabled, SetTextDelegate setStateText,
|
||
SetTextDelegate addTextToCompilerMessages, ToolStripMenuItem pluginsMenuItem,
|
||
ToolStrip pluginsToolStrip, ExecuteSourceLocationActionDelegate ExecuteSLAction,
|
||
ExecuteVisualEnvironmentCompilerActionDelegate ExecuteVECAction,
|
||
PascalABCCompiler.Errors.ErrorsStrategyManager ErrorsManager, RunManager RunnerManager, DebugHelper DebugHelper,UserOptions UserOptions, Dictionary<string, string> StandartDirectories,
|
||
Dictionary<string, CodeFileDocumentControl> OpenDocuments, IWorkbench workbench)
|
||
{
|
||
this.StandartDirectories = StandartDirectories;
|
||
this.ErrorsManager = ErrorsManager;
|
||
this.ChangeVisualEnvironmentState += onChangeVisualEnvironmentState;
|
||
SetCompilingAndRunButtonsEnabled = setCompilingAndRunButtonsEnabled;
|
||
SetDebugButtonsEnabled = setCompilingDebugEnabled;
|
||
SetStateText = setStateText;
|
||
AddTextToCompilerMessages = addTextToCompilerMessages;
|
||
this.beginInvoke = beginInvoke;
|
||
this.ExecuteSLAction=ExecuteSLAction;
|
||
this.ExecuteVECAction = ExecuteVECAction;
|
||
PluginsMenuItem = pluginsMenuItem;
|
||
PluginsToolStrip = pluginsToolStrip;
|
||
PluginsController = new PluginsController(this, PluginsMenuItem, PluginsToolStrip, workbench);
|
||
this.RunnerManager = RunnerManager;
|
||
this.DebugHelper = DebugHelper;
|
||
DebugHelper.Starting += DebugHelper_Starting;
|
||
DebugHelper.Exited += DebugHelper_Exited;
|
||
RunnerManager.Starting += RunnerManager_Starting;
|
||
RunnerManager.Exited += RunnerManager_Exited;
|
||
this.CodeCompletionParserController = WorkbenchServiceFactory.CodeCompletionParserController;
|
||
this.CodeCompletionParserController.visualEnvironmentCompiler = this;
|
||
this.UserOptions = UserOptions;
|
||
this.OpenDocuments = OpenDocuments;
|
||
|
||
LanguageIntegrator.LanguageLoaded += OnLanguageLoaded;
|
||
LanguageIntegrator.LanguageLoadErrorOccured += OnLanguageLoadErrorOccured;
|
||
}
|
||
|
||
void RunnerManager_Exited(string fileName)
|
||
{
|
||
ChangeVisualEnvironmentState(VisualEnvironmentState.ProcessExited, fileName);
|
||
}
|
||
|
||
void RunnerManager_Starting(string fileName)
|
||
{
|
||
ChangeVisualEnvironmentState(VisualEnvironmentState.ProcessStarting, fileName);
|
||
}
|
||
|
||
void DebugHelper_Exited(string FileName)
|
||
{
|
||
ChangeVisualEnvironmentState(VisualEnvironmentState.ProcessExited, FileName);
|
||
}
|
||
|
||
void DebugHelper_Starting(string FileName)
|
||
{
|
||
ChangeVisualEnvironmentState(VisualEnvironmentState.ProcessStartingDebug, FileName);
|
||
}
|
||
|
||
|
||
public bool Starting()
|
||
{
|
||
return StartingThread.ThreadState == System.Threading.ThreadState.Running;
|
||
}
|
||
public bool Started
|
||
{
|
||
get { return StartingThread.ThreadState != System.Threading.ThreadState.Running; }
|
||
}
|
||
public void AbortStaring()
|
||
{
|
||
//для того чтобы отмена прошла быстрее увеличиваем приоритет потока
|
||
StartingThread.Priority = System.Threading.ThreadPriority.AboveNormal;
|
||
//даем команду на завершение и ждем завершения
|
||
StartingThread.Join();
|
||
}
|
||
|
||
private void CreateCompiler()
|
||
{
|
||
standartCompiler = new PascalABCCompiler.Compiler(SourceFilesProvider, OnChangeCompilerState);
|
||
CodeCompletion.CodeCompletionController.comp = new PascalABCCompiler.Compiler((PascalABCCompiler.Compiler)standartCompiler, SourceFilesProvider, OnChangeCompilerState);
|
||
if (ProjectFactory.Instance.CurrentProject != null)
|
||
{
|
||
CodeCompletion.CodeCompletionController.comp.CompilerOptions.CurrentProject = ProjectFactory.Instance.CurrentProject;
|
||
ProjectFactory.Instance.Dirty = true;
|
||
}
|
||
CodeCompletion.CodeCompletionController.StandartDirectories = StandartDirectories;
|
||
|
||
this.CodeCompletionParserController.Init();
|
||
if (defaultCompilerType == PascalABCCompiler.CompilerType.Remote && !Tools.IsUnix())
|
||
LoadRemoteCompiler();
|
||
else
|
||
defaultCompilerType = PascalABCCompiler.CompilerType.Standart;
|
||
}
|
||
|
||
public void LoadRemoteCompiler()
|
||
{
|
||
remoteCompiler = new PascalABCCompiler.RemoteCompiler(PascalABCCompiler.ConsoleCompilerConstants.MaxProcessMemoryMB, OnChangeCompilerState, SourceFilesProvider);
|
||
}
|
||
|
||
public void RunStartingThread()
|
||
{
|
||
StartingThread = new System.Threading.Thread(new System.Threading.ThreadStart(CreateCompiler));
|
||
StartingThread.Priority = System.Threading.ThreadPriority.BelowNormal;
|
||
ChangeVisualEnvironmentState(VisualEnvironmentState.StartCompilerLoading, StartingThread);
|
||
StartingThread.Start();
|
||
}
|
||
|
||
public string GetFilterForDialogs()
|
||
{
|
||
if (standartCompiler == null)
|
||
return null;
|
||
string Filter = "", AllFilter = "";
|
||
foreach (ILanguage lang in LanguageProvider.Instance.Languages)
|
||
{
|
||
Filter = Tools.MakeFilter(Filter, lang.Name, lang.FilesExtensions);
|
||
AllFilter = Tools.MakeAllFilter(AllFilter, lang.Name, lang.FilesExtensions);
|
||
}
|
||
Filter += "Программы на C# (*.cs)|*.cs|";
|
||
AllFilter += "*.cs;";
|
||
return Tools.FinishMakeFilter(Filter, AllFilter);
|
||
}
|
||
|
||
public string GetProjectFilterForDialogs()
|
||
{
|
||
if (standartCompiler == null)
|
||
return null;
|
||
string Filter = "", AllFilter = "";
|
||
foreach (ILanguage lang in LanguageProvider.Instance.Languages)
|
||
{
|
||
Filter = Tools.MakeProjectFilter(Filter, lang.Name,
|
||
new string[1] { PascalABCCompiler.StringConstants.platformProjectExtension });
|
||
}
|
||
|
||
AllFilter = Tools.MakeAllFilter(AllFilter, PascalABCCompiler.StringConstants.pascalLanguageName,
|
||
new string[1] { PascalABCCompiler.StringConstants.platformProjectExtension });
|
||
return Tools.FinishMakeFilter(Filter, AllFilter);
|
||
}
|
||
|
||
public string GetAssemblyFilterForDialogs()
|
||
{
|
||
if (standartCompiler == null)
|
||
return null;
|
||
string Filter = "";
|
||
string AllFilter = "";
|
||
Filter = Tools.MakeFilter(Filter, VECStringResources.Get("ASSEMBLIES"), new string[1]{".dll"});
|
||
AllFilter = Tools.MakeAllFilter(AllFilter, VECStringResources.Get("ASSEMBLIES"), new string[1]{".dll"});
|
||
return Tools.FinishMakeFilter(Filter, AllFilter);
|
||
}
|
||
|
||
private bool CurrentThreadIsMainThread()
|
||
{
|
||
return MainProgramThread == System.Threading.Thread.CurrentThread;
|
||
}
|
||
|
||
DateTime compilationStartTime;
|
||
public string Compile(PascalABCCompiler.CompilerOptions CompilerOptions)
|
||
{
|
||
compilationStartTime = DateTime.Now;
|
||
Compiler.CompilerOptions = CompilerOptions;
|
||
string fn=Compiler.Compile();
|
||
return fn;
|
||
}
|
||
|
||
public void StartCompile(PascalABCCompiler.CompilerOptions CompilerOptions)
|
||
{
|
||
compilationStartTime = DateTime.Now;
|
||
Compiler.CompilerOptions = CompilerOptions;
|
||
Compiler.StartCompile();
|
||
}
|
||
|
||
void onChangeVisualEnvironmentState(VisualEnvironmentState State, object obj)
|
||
{
|
||
|
||
}
|
||
|
||
|
||
public object SourceFilesProvider(string FileName, PascalABCCompiler.SourceFileOperation FileOperation)
|
||
{
|
||
|
||
|
||
CodeFileDocumentControl tp = null;
|
||
ICSharpCode.TextEditor.TextEditorControl ed = null;
|
||
if (OpenDocuments.TryGetValue(Tools.FileNameToLower(FileName), out tp))
|
||
ed = tp.TextEditor;
|
||
|
||
|
||
switch (FileOperation)
|
||
{
|
||
case PascalABCCompiler.SourceFileOperation.GetText:
|
||
if (tp != null)
|
||
{
|
||
string Text1 = ed.Document.TextContent;
|
||
if (ConvertUnitTextProperty != null)
|
||
Text1 = ConvertUnitTextProperty(FileName, Text1);
|
||
return Text1;
|
||
}
|
||
|
||
if (!File.Exists(FileName))
|
||
return null;
|
||
/*TextReader tr = new StreamReader(file_name, System.Text.Encoding.GetEncoding(1251));
|
||
string Text = tr.ReadToEnd();
|
||
tr.Close();*/
|
||
string Text = PascalABCCompiler.FileReader.ReadFileContent(FileName, null);
|
||
if (ConvertUnitTextProperty != null)
|
||
Text = ConvertUnitTextProperty(FileName, Text);
|
||
return Text;
|
||
case PascalABCCompiler.SourceFileOperation.Exists:
|
||
if (tp != null)
|
||
return true;
|
||
return File.Exists(FileName);
|
||
case PascalABCCompiler.SourceFileOperation.GetLastWriteTime:
|
||
if (tp != null)
|
||
return tp.ModifyDateTime;
|
||
return File.GetLastWriteTime(FileName);
|
||
case PascalABCCompiler.SourceFileOperation.FileEncoding:
|
||
return DefaultFileEncoding;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private delegate void ChangeCompilerStateDelegate(PascalABCCompiler.ICompiler sender, PascalABCCompiler.CompilerState State, string FileName);
|
||
private void OnChangeCompilerState(PascalABCCompiler.ICompiler sender, PascalABCCompiler.CompilerState State, string FileName)
|
||
{
|
||
if (CurrentThreadIsMainThread())
|
||
OnChangeCompilerStateEx(sender, State, FileName);
|
||
else
|
||
BeginInvoke(new ChangeCompilerStateDelegate(OnChangeCompilerStateEx), sender, State, FileName);
|
||
}
|
||
|
||
private void CompileTestProgram(object state)
|
||
{
|
||
string fileName = @"C:\PABCWork.NET\Samples\test.pas";
|
||
if (File.Exists(fileName))
|
||
{
|
||
PascalABCCompiler.CompilerOptions co = new PascalABCCompiler.CompilerOptions();
|
||
co.SourceFileName = fileName;
|
||
Compile(co);
|
||
}
|
||
}
|
||
|
||
private void LoadPlugins(object state)
|
||
{
|
||
AddTextToCompilerMessages(VECStringResources.Get("LOAD_PLUGINS") + Environment.NewLine);
|
||
PluginsController.AddPlugins();
|
||
if (PluginsController.Plugins.Count == 0)
|
||
AddTextToCompilerMessages(VECStringResources.Get("PLUGINS_NOTFOUND") + Environment.NewLine);
|
||
else
|
||
foreach (VisualPascalABCPlugins.IVisualPascalABCPlugin Plugin in PluginsController.Plugins)
|
||
AddTextToCompilerMessages(Plugin.Name+" v"+Plugin.Version + Environment.NewLine);
|
||
if (PluginsController.ErrorList.Count > 0)
|
||
{
|
||
AddTextToCompilerMessages(VECStringResources.Get("PLUGINS_LOADING_ERRORS") + Environment.NewLine);
|
||
foreach (VisualPascalABCPlugins.PluginLoadingError Error in PluginsController.ErrorList)
|
||
AddTextToCompilerMessages(Error.ToString() + Environment.NewLine);
|
||
}
|
||
|
||
//VisualPABCSingleton.MainForm.codeCompletionParserController.ParseAllFiles();
|
||
}
|
||
|
||
void AddCompilerTextToCompilerMessages(PascalABCCompiler.ICompiler sender, string text)
|
||
{
|
||
if (sender.CompilerType == PascalABCCompiler.CompilerType.Standart)
|
||
AddTextToCompilerMessages(VECStringResources.Get("LOCAL_COMPILER_PREFIX") + text);
|
||
else
|
||
AddTextToCompilerMessages(VECStringResources.Get("REMOTE_COMPILER_PREFIX") + text);
|
||
}
|
||
List<string> ParsedFiles = new List<string>();
|
||
|
||
/// <summary>
|
||
/// Выводит сообщения о подключенных языках
|
||
/// </summary>
|
||
private void OnLanguageLoaded(Languages.Facade.ILanguage language)
|
||
{
|
||
string languageConnectedMessage = string.Format(VECStringResources.Get("LANGUAGE_LOADED{0}"), language.Name);
|
||
languageConnectedMessage += Environment.NewLine;
|
||
AddTextToCompilerMessages(languageConnectedMessage);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Выводит сообщения об ошибках, возникших при загрузке языков
|
||
/// </summary>
|
||
private void OnLanguageLoadErrorOccured(string languageFileName)
|
||
{
|
||
string languageLoadErrorMessage = string.Format(VECStringResources.Get("LANGUAGE_LOAD_ERROR{0}"), Path.GetFileName(languageFileName));
|
||
languageLoadErrorMessage += Environment.NewLine;
|
||
AddTextToCompilerMessages(languageLoadErrorMessage);
|
||
}
|
||
|
||
private void OnChangeCompilerStateEx(PascalABCCompiler.ICompiler sender, PascalABCCompiler.CompilerState State, string FullFileName)
|
||
{
|
||
|
||
string RusName = null;
|
||
string FileName = null;
|
||
if (FullFileName != null)
|
||
FileName = Path.GetFileName(FullFileName);
|
||
switch (State)
|
||
{
|
||
case PascalABCCompiler.CompilerState.CompilationStarting:
|
||
RusName = VECStringResources.Get("STATE_START_COMPILING_ASSEMBLY{0}");
|
||
SetCompilingAndRunButtonsEnabled(false);
|
||
ParsedFiles.Clear();
|
||
break;
|
||
case PascalABCCompiler.CompilerState.BeginCompileFile: RusName = VECStringResources.Get("STATE_BEGINCOMPILEFILE{0}"); break;
|
||
case PascalABCCompiler.CompilerState.CompileInterface: RusName = VECStringResources.Get("STATE_COMPILEINTERFACE{0}"); break;
|
||
case PascalABCCompiler.CompilerState.CompileImplementation: RusName = VECStringResources.Get("STATE_COMPILEIMPLEMENTATION{0}"); break;
|
||
case PascalABCCompiler.CompilerState.EndCompileFile: RusName = VECStringResources.Get("STATE_ENDCOMPILEFILE{0}"); break;
|
||
case PascalABCCompiler.CompilerState.CodeGeneration: RusName = VECStringResources.Get("STATE_CODEGENERATION{0}"); break;
|
||
case PascalABCCompiler.CompilerState.ReadDLL: RusName = VECStringResources.Get("STATE_READDLL{0}"); break;
|
||
case PascalABCCompiler.CompilerState.SavePCUFile: RusName = VECStringResources.Get("STATE_SAVEPCUFILE{0}"); break;
|
||
case PascalABCCompiler.CompilerState.ReadPCUFile: RusName = VECStringResources.Get("STATE_READPCUFILE{0}"); break;
|
||
case PascalABCCompiler.CompilerState.PCUReadingError: RusName = VECStringResources.Get("STATE_PCUREADINGERROR{0}"); break;
|
||
case PascalABCCompiler.CompilerState.PCUWritingError: RusName = VECStringResources.Get("STATE_PCUWRITINGERROR{0}"); break;
|
||
case PascalABCCompiler.CompilerState.SemanticTreeConversion: RusName = VECStringResources.Get("STATE_SEMANTICTREECONVERSION{0}"); break;
|
||
case PascalABCCompiler.CompilerState.SemanticTreeConverterConnected: RusName = VECStringResources.Get("STATE_SEMANTICTREECONVERTERCONNECTED{0}"); break;
|
||
case PascalABCCompiler.CompilerState.SyntaxTreeConversion: RusName = VECStringResources.Get("STATE_SYNTAXTREECONVERSION{0}"); break;
|
||
case PascalABCCompiler.CompilerState.Ready:
|
||
RusName = VECStringResources.Get("STATE_READY");
|
||
if (!StartingCompleted)
|
||
{
|
||
switch (sender.CompilerType)
|
||
{
|
||
case PascalABCCompiler.CompilerType.Standart:
|
||
standartCompiler = (PascalABCCompiler.Compiler)sender;
|
||
break;
|
||
case PascalABCCompiler.CompilerType.Remote:
|
||
remoteCompiler = (PascalABCCompiler.RemoteCompiler)sender;
|
||
break;
|
||
}
|
||
if (!(defaultCompilerType == PascalABCCompiler.CompilerType.Remote) || (standartCompiler.State == PascalABCCompiler.CompilerState.Ready && (remoteCompiler != null && remoteCompiler.State == PascalABCCompiler.CompilerState.Ready)))
|
||
StartingCompleted = true;
|
||
AddCompilerTextToCompilerMessages(sender, VECStringResources.Get("SUPPORTED_LANGUAGES") + Environment.NewLine);
|
||
foreach (ILanguage lang in LanguageProvider.Instance.Languages)
|
||
AddCompilerTextToCompilerMessages(sender, string.Format(VECStringResources.Get("CM_LANGUAGE_{0}"),
|
||
PascalABCCompiler.FormatTools.LanguageAndExtensionsFormatted(lang.Name, lang.FilesExtensions) + Environment.NewLine));
|
||
if (StartingCompleted)
|
||
{
|
||
ChangeVisualEnvironmentState(VisualEnvironmentState.FinishCompilerLoading, standartCompiler);
|
||
compilerLoaded = true;
|
||
VisualPABCSingleton.MainForm.StartTimer();
|
||
/*if (!ThreadPool.QueueUserWorkItem(new WaitCallback(CompileTestProgram)))
|
||
CompileTestProgram(null);*/
|
||
if (!ThreadPool.QueueUserWorkItem(new WaitCallback(LoadPlugins)))
|
||
LoadPlugins(null);
|
||
|
||
SetCompilingAndRunButtonsEnabled(true);
|
||
if (CodeCompletion.CodeCompletionController.IntellisenseAvailable())
|
||
SetDebugButtonsEnabled(true);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (Compiler == sender)
|
||
{
|
||
SetCompilingAndRunButtonsEnabled(true);
|
||
}
|
||
}
|
||
break;
|
||
case PascalABCCompiler.CompilerState.Reloading:
|
||
if (Compiler == sender)
|
||
SetCompilingAndRunButtonsEnabled(false);
|
||
RusName = VECStringResources.Get("STATE_RELOADING");
|
||
break;
|
||
case PascalABCCompiler.CompilerState.CompilationFinished:
|
||
RusName = VECStringResources.Get("STATE_COMPILATIONFINISHED{0}");
|
||
if (Compiler.ErrorsList.Count == 0)
|
||
{
|
||
SaveSourceFilesIfCompilationOk();
|
||
AddTextToCompilerMessages(string.Format(VECStringResources.Get("CM_OK_{0}MS") + Environment.NewLine, (DateTime.Now - compilationStartTime).TotalMilliseconds) + Environment.NewLine);
|
||
}
|
||
else
|
||
{
|
||
List<PascalABCCompiler.Errors.Error> ErrorsList = ErrorsManager.CreateErrorsList(Compiler.ErrorsList);
|
||
AddTextToCompilerMessages(string.Format(VECStringResources.Get("CM_{0}_ERROS") + Environment.NewLine, ErrorsList.Count));
|
||
foreach (PascalABCCompiler.Errors.Error Err in ErrorsList)
|
||
AddTextToCompilerMessages(Err.ToString() + Environment.NewLine);
|
||
}
|
||
|
||
break;
|
||
default:
|
||
//RusName = State.ToString();
|
||
break;
|
||
}
|
||
if (RusName != null)
|
||
{
|
||
if (FileName != null)
|
||
RusName = string.Format(RusName, FileName);
|
||
else RusName = string.Format(RusName, "");
|
||
RusName += Environment.NewLine;
|
||
AddCompilerTextToCompilerMessages(sender, RusName);
|
||
}
|
||
|
||
RusName = null;
|
||
switch (State)
|
||
{
|
||
case PascalABCCompiler.CompilerState.BeginParsingFile:
|
||
ParsedFiles.Add(FullFileName);
|
||
break;
|
||
case PascalABCCompiler.CompilerState.BeginCompileFile: RusName = VECStringResources.Get("STATETEXT_BEGINCOMPILEFILE{0}"); break;
|
||
//case PascalABCCompiler.CompilerState.ReadPCUFile: RusName = "Чтение {0}..."; break;
|
||
case PascalABCCompiler.CompilerState.CodeGeneration: RusName = VECStringResources.Get("STATETEXT_CODEGENERATION{0}"); break;
|
||
//case PascalABCCompiler.CompilerState.ReadDLL:
|
||
//case PascalABCCompiler.CompilerState.ReadPCUFile: RusName = "Чтение {0}..."; break;
|
||
case PascalABCCompiler.CompilerState.Ready:
|
||
if (Compiler != null)
|
||
{
|
||
List<PascalABCCompiler.Errors.Error> ErrorsList = ErrorsManager.CreateErrorsList(Compiler.ErrorsList);
|
||
if (ErrorsList.Count > 0)
|
||
{
|
||
RusName = string.Format(VECStringResources.Get("STATETEXT_{0}_ERROS"), ErrorsList.Count);
|
||
}
|
||
else
|
||
if (Compilation)
|
||
{
|
||
if (Compiler.Warnings.Count > 0)
|
||
RusName = string.Format(VECStringResources.Get("STATETEXT_COMPILATION_SUCCESS_{0}LINES_{1}WARNINGS"), Compiler.LinesCompiled, Compiler.Warnings.Count);
|
||
else
|
||
RusName = string.Format(VECStringResources.Get("STATETEXT_COMPILATION_SUCCESS_{0}LINES"), Compiler.LinesCompiled);
|
||
}
|
||
else
|
||
RusName = VECStringResources.Get("STATETEXT_READY");
|
||
}
|
||
else
|
||
RusName = VECStringResources.Get("STATETEXT_READY");
|
||
break;
|
||
case PascalABCCompiler.CompilerState.Reloading: RusName = VECStringResources.Get("STATETEXT_RELOADING"); break;
|
||
}
|
||
if (RusName != null)
|
||
{
|
||
if (FileName != null)
|
||
RusName = string.Format(RusName, FileName);
|
||
SetStateText(RusName);
|
||
|
||
|
||
}
|
||
if (!Compilation && State == PascalABCCompiler.CompilerState.CompilationStarting)
|
||
Compilation = true;
|
||
if (Compilation && State == PascalABCCompiler.CompilerState.Ready)
|
||
Compilation = false;
|
||
}
|
||
|
||
|
||
void SaveSourceFilesIfCompilationOk()
|
||
{
|
||
if (!UserOptions.SaveSourceFilesIfComilationOk)
|
||
return;
|
||
foreach (string name in ParsedFiles)
|
||
ExecuteAction(VisualEnvironmentCompilerAction.SaveFile, name);
|
||
}
|
||
|
||
#region IVisualEnvironmentCompiler Members
|
||
|
||
public event ChangeVisualEnvironmentStateDelegate ChangeVisualEnvironmentState;
|
||
|
||
public PascalABCCompiler.ICompiler Compiler
|
||
{
|
||
get
|
||
{
|
||
if (defaultCompilerType == PascalABCCompiler.CompilerType.Remote)
|
||
return remoteCompiler;
|
||
return standartCompiler;
|
||
}
|
||
}
|
||
public PascalABCCompiler.Compiler StandartCompiler
|
||
{
|
||
get
|
||
{
|
||
return standartCompiler;
|
||
}
|
||
}
|
||
public PascalABCCompiler.RemoteCompiler RemoteCompiler
|
||
{
|
||
get
|
||
{
|
||
return remoteCompiler;
|
||
}
|
||
}
|
||
|
||
public void ExecuteSourceLocationAction(PascalABCCompiler.SourceLocation SourceLocation,SourceLocationAction Action)
|
||
{
|
||
ExecuteSLAction(SourceLocation,Action);
|
||
}
|
||
|
||
public object ExecuteAction(VisualEnvironmentCompilerAction Action, object obj)
|
||
{
|
||
return ExecuteVECAction(Action, obj);
|
||
}
|
||
|
||
public PascalABCCompiler.CompilerType DefaultCompilerType
|
||
{
|
||
get
|
||
{
|
||
return defaultCompilerType;
|
||
}
|
||
set
|
||
{
|
||
if (defaultCompilerType == value)
|
||
return;
|
||
defaultCompilerType=value;
|
||
if (defaultCompilerType == PascalABCCompiler.CompilerType.Remote && remoteCompiler == null)
|
||
{
|
||
LoadRemoteCompiler();
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
}
|