/// <summary>
/// Class constructor from highlighting theme definition resolver
/// and highlighting definition (and resolver)
/// </summary>
/// <param name="xshd"></param>
/// <param name="resolver"></param>
/// <param name="themedHighlights"></param>
public XmlHighlightingDefinition(SyntaxDefinition themedHighlights,
XshdSyntaxDefinition xshd,
IHighlightingDefinitionReferenceResolver resolver)
{
_themedHighlights = themedHighlights;
InitializeDefinitions(xshd, resolver);
}
Func <IHighlightingDefinition> LoadHighlighting(IHLTheme theme, string name, string resourceName)
{
Func <IHighlightingDefinition> func = delegate
{
ICSharpCode.AvalonEdit.Highlighting.Xshd.XshdSyntaxDefinition xshd;
using (Stream s = HLResources.OpenStream(GetPrefix(CurrentTheme.HLBaseKey), resourceName))
{
using (XmlTextReader reader = new XmlTextReader(s))
{
// in release builds, skip validating the built-in highlightings
xshd = HighlightingLoader.LoadXshd(reader, true);
}
}
var hlTheme = theme.HlTheme;
SyntaxDefinition themedHighlights = null;
if (hlTheme != null)
{
themedHighlights = hlTheme.GetNamedSyntaxDefinition(name);
}
return(HighlightingLoader.Load(themedHighlights, xshd, this));
};
return(func);
}
/// <summary>
/// Implements the visitor for the <see cref="XshtdSyntaxDefinition"/> object.
/// </summary>
/// <param name="syntax"></param>
/// <returns></returns>
public object VisitSyntaxDefinition(XshtdSyntaxDefinition syntax)
{
SyntaxDefinition c;
if (syntax.Name != null)
{
c = def.syntaxDefDict[syntax.Name];
}
else
{
if (syntax.Extensions == null)
{
return(null);
}
else
{
c = new SyntaxDefinition(syntax.Name);
}
}
// Copy extensions to highlighting theme object
foreach (var item in syntax.Extensions)
{
c.Extensions.Add(item);
}
syntax.AcceptElements(this);
return(c);
}
private SourceCodePrintDocument getPrintDocument(string name)
{
//get the filename for the syntax definition so we can
//reload it and apply our own styleset for printing.
int index = Array.IndexOf(p_SyntaxDefinitions, p_SyntaxDefinition);
string filename = p_SyntaxDefinitionFilenames[index];
//load the syntax defintion
SyntaxDefinition definition = SyntaxDefinition.FromSyntaxFile(filename);
applyStyle(definition.Styles, Color.White, Color.Black);
//clone the current document under the new syntax definitions
SyntaxDocument document = new SyntaxDocument();
document.Parser.Init(definition);
document.Text = Contents;
//return a printable document
return(new SourceCodePrintDocument()
{
Document = document,
DocumentName = name
});
}
public static void Initialize()
{
//load every syntax definition in the /syntax folder
foreach (FileInfo f in new DirectoryInfo("./syntax").GetFiles())
{
if (f.Extension.ToLower() != ".syn")
{
continue;
}
Array.Resize(ref p_SyntaxDefinitions, p_SyntaxDefinitions.Length + 1);
Array.Resize(ref p_SyntaxNames, p_SyntaxNames.Length + 1);
Array.Resize(ref p_SyntaxDefinitionFilenames, p_SyntaxDefinitionFilenames.Length + 1);
p_SyntaxDefinitions[p_SyntaxDefinitions.Length - 1] =
SyntaxDefinition.FromSyntaxFile(f.FullName);
p_SyntaxNames[p_SyntaxNames.Length - 1] =
f.Name.Replace(f.Extension, "").ToLower();
p_SyntaxDefinitionFilenames[p_SyntaxDefinitionFilenames.Length - 1] =
f.FullName;
//apply the style set
applyStyle(
p_SyntaxDefinitions[p_SyntaxDefinitions.Length - 1].Styles,
Color.FromArgb(255, 34, 40, 42),
Color.White
);
}
//trigger initialization of the syntax highlighter core
new SyntaxBoxControl().Dispose();
}
private List<Scope> m_scopeStack; // our "stack" is a List<T> because Stack<T> doesn't let us access items by index.
#endregion Fields
#region Constructors
internal Scanner(SyntaxDefinition syntaxDefinition)
{
ArgumentValidator.ThrowIfNull(syntaxDefinition, "syntaxDefinition");
this.m_syntaxDefinition = syntaxDefinition;
this.m_isFirstRun = true;
}
public void TestCircularClusterDefinition()
{
SyntaxDefinition circular = new SyntaxDefinition("circular");
SyntaxContext mainContext = circular.MainContext;
new Keyword(mainContext, "seventeenth", "JohnLocke", true);
new Keyword(mainContext, "seventeenth", "Newton", true);
new Keyword(mainContext, "eighteenth", "Voltaire", true);
new Keyword(mainContext, "eighteenth", "AdamSmith", true);
new Keyword(mainContext, "nineteenth", "KarlMarx", true);
new Keyword(mainContext, "nineteenth", "Maxwell", true);
new Keyword(mainContext, "twentieth", "Einstein", true);
new Keyword(mainContext, "twentieth", "Chomsky", true);
circular.GetCluster("@Everybody", mainContext).SetContentsTo("@Everybody,seventeenth,eighteenth,nineteenth,twentieth,@Everybody");
circular.GetCluster("@Thing1", mainContext).SetContentsTo("seventeenth,@Thing2");
circular.GetCluster("@Thing2", mainContext).SetContentsTo("eighteenth,@Thing1");
circular.FinishSyntaxDefinition();
Assert.AreEqual(8, circular.GetCluster("@Everybody", mainContext).CachedMemberItems.Items.Length);
Assert.AreEqual(4, circular.GetCluster("@Thing1", mainContext).CachedMemberItems.Items.Length);
Assert.AreEqual(4, circular.GetCluster("@Thing2", mainContext).CachedMemberItems.Items.Length);
}
public SettingsForm(SyntaxBoxControl sb)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.sb = sb;
SyntaxDefinition l = sb.Document.Parser.SyntaxDefinition;
TextStyle[] tss = l.Styles;
lbStyles.Items.Clear();
for (int i = 0; i < tss.Length; i++)
{
TextStyle ts = tss[i];
var s = new Style {
TextStyle = ts, Name = ts.Name
};
//s.Name=ts.Name;
lbStyles.Items.Add(s);
}
lbStyles.SelectedIndex = 0;
}
/// <summary>
/// Registering a built-in highlighting including highlighting themes (if any).
/// </summary>
/// <param name="theme"></param>
/// <param name="name"></param>
/// <param name="extensions"></param>
/// <param name="resourceName"></param>
internal void RegisterHighlighting(IHLTheme theme,
string name,
string[] extensions,
string resourceName)
{
try
{
#if DEBUG
// don't use lazy-loading in debug builds, show errors immediately
ICSharpCode.AvalonEdit.Highlighting.Xshd.XshdSyntaxDefinition xshd;
using (Stream s = HLResources.OpenStream(GetPrefix(CurrentTheme.HLBaseKey), resourceName))
{
using (XmlTextReader reader = new XmlTextReader(s))
{
xshd = HighlightingLoader.LoadXshd(reader, false);
}
}
Debug.Assert(name == xshd.Name);
if (extensions != null)
{
Debug.Assert(System.Linq.Enumerable.SequenceEqual(extensions, xshd.Extensions));
}
else
{
Debug.Assert(xshd.Extensions.Count == 0);
}
var hlTheme = theme.HlTheme;
SyntaxDefinition themedHighlights = null;
if (hlTheme != null)
{
themedHighlights = hlTheme.GetNamedSyntaxDefinition(name);
}
// round-trip xshd:
// string resourceFileName = Path.Combine(Path.GetTempPath(), resourceName);
// using (XmlTextWriter writer = new XmlTextWriter(resourceFileName, System.Text.Encoding.UTF8)) {
// writer.Formatting = Formatting.Indented;
// new Xshd.SaveXshdVisitor(writer).WriteDefinition(xshd);
// }
// using (FileStream fs = File.Create(resourceFileName + ".bin")) {
// new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter().Serialize(fs, xshd);
// }
// using (FileStream fs = File.Create(resourceFileName + ".compiled")) {
// new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter().Serialize(fs, Xshd.HighlightingLoader.Load(xshd, this));
// }
base.RegisterHighlighting(name, extensions,
HighlightingLoader.Load(themedHighlights, xshd, this));
#else
base.RegisterHighlighting(name, extensions, LoadHighlighting(theme, name, resourceName));
#endif
}
catch (HighlightingDefinitionInvalidException ex)
{
throw new InvalidOperationException("The built-in highlighting '" + name + "' is invalid.", ex);
}
}
/// <summary>
/// Gets the syntaxdefinition colors that should be applied for a certain highlighting (eg 'C#')
/// within this theme (eg TrueBlue).
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public SyntaxDefinition GetNamedSyntaxDefinition(string name)
{
SyntaxDefinition item = null;
syntaxDefDict.TryGetValue(name, out item);
return(item);
}
//create an EditForm and attatch our opened document and tell the parser to use the given syntax.
public EditForm(Document doc, string docText, SyntaxDefinition synDef) :
this()
{
Doc = doc;
sBox.Document.Parser.Init(synDef);
sBox.Document.Text = docText;
Text = Doc.Title;
}
internal SyntaxContext(SyntaxDefinition syntaxDefinition, string scopeName)
{
this.SyntaxDefinition = syntaxDefinition;
this.AllItems = new List<SyntaxItem>(16);
this.NonTopItems = new SetOfSyntaxItems();
this.TopItems = new SetOfSyntaxItems();
this.Name = scopeName;
this.TopClusters = new List<Cluster>(2);
}
internal Cluster(SyntaxContext context)
{
ArgumentValidator.ThrowIfNull(context, "scope");
this.m_containedGroupsAndClusters = new List<string>();
this.m_syntaxContext = context;
this.m_ClusterType = ClusterType.NONMAGIC;
this.m_directItems = new SetOfSyntaxItems();
this.m_syntaxDefinition = context.SyntaxDefinition;
}
public EditForm(Document Document, SyntaxDefinition SyntaxDefinition)
{
InitializeComponent();
Doc = Document;
sBox.Document = sDoc;
sBox.Document.Parser.Init(SyntaxDefinition);
sBox.Document.Text = Document.Text;
Text = Doc.Title;
}
private void mnuFile_Open_Click(object sender, EventArgs e)
{
//create a filter for the open dialog
//add a *.* pattern to the filter
string filter = "All Files(*.*)|*.*";
//get all filetypes from our syntax list.
foreach (SyntaxDefinition l in Languages.GetSyntaxDefinitions())
{
foreach (FileType ft in l.FileTypes)
{
//add the filetype to the filter
filter += "|" + ft.Name + "(*" + ft.Extension + ")|*" + ft.Extension;
}
}
//apply the filter to the dialog
dlgOpen.Filter = filter;
//Show the open dialog
dlgOpen.Title = "Select a file to open";
DialogResult res = dlgOpen.ShowDialog(this);
//Bail out if cancel was pressed or no file was selected.
if (res != DialogResult.OK || dlgOpen.FileName == "")
{
return;
}
//load the file
string FileName = dlgOpen.FileName;
var sr = new StreamReader(FileName, Encoding.Default);
//read the content into the "text" variable
string text = sr.ReadToEnd();
//create a new document
var doc = new Document {
Path = FileName
};
var fi = new FileInfo(FileName);
doc.Title = fi.Name;
doc.Text = text;
SyntaxDefinition syntax = Languages.GetLanguageFromFile(doc.Path);
var ef = new EditForm(doc, syntax)
{
MdiParent = this
};
ef.Show();
}
private void setSyntax(string synName)
{
string resName = string.Format("SQL8r.WinForms.SyntaxFiles.{0}.syn", synName);
string xml = ResourceReader.GetResourceSyntax(resName);
var s = new SyntaxDefinitionLoader();
SyntaxDefinition l = s.LoadXML(xml);
_view.txtEditor.Document.Parser.Init(l);
}
private void TemplateEditor_Load(object sender, EventArgs e)
{
var sl = new SyntaxDefinitionLoader();
SyntaxDefinition lang = sl.LoadXML(Resources.CSharpTemplate);
TemplateSyntaxBox.Document.Parser.Init(lang);
lang = sl.LoadXML(Resources.CSharp);
SourceSyntaxBox.Document.Parser.Init(lang);
OutputSyntaxBox.Document.Parser.Init(lang);
}
public void Init(string syntaxDefinitionPath)
{
if (!syntaxDefinitionPath.ToLowerInvariant().EndsWith(".syn"))
{
syntaxDefinitionPath += ".syn";
}
var loader = new SyntaxDefinitionLoader();
SyntaxDefinition syntax = loader.Load(syntaxDefinitionPath);
Init(syntax);
}
internal Group(string name, SyntaxDefinition syntaxDefinition)
{
this.m_name = name;
this.m_syntaxDefinition = syntaxDefinition;
this.m_items = new List<SyntaxItem>();
if (m_builtinHighlightModes.ContainsKey(name)) {
this.m_highlightMode = m_builtinHighlightModes[name];
} else {
this.m_highlightMode = HighlightMode.Normal;
}
}
/// <summary>
/// Loads a highlighting definition base on a:
/// </summary>
/// <param name="themedHighlights">
/// Themed Highlighting Definition
/// (This contains the color definition for a highlighting in this theme)
/// </param>
/// <param name="syntaxDefinition">
/// A Highlighting definition
/// (This contains the pattern matching and color definitions where the later
/// is usually overwritten be a highlighting theme)
/// </param>
/// <param name="resolver">An object that can resolve a highlighting definition by its name.</param>
/// <returns></returns>
public static IHighlightingDefinition Load(SyntaxDefinition themedHighlights,
XshdSyntaxDefinition syntaxDefinition,
IHighlightingDefinitionReferenceResolver resolver
)
{
if (syntaxDefinition == null)
{
throw new ArgumentNullException("syntaxDefinition");
}
return(new XmlHighlightingDefinition(themedHighlights, syntaxDefinition, resolver));
}
internal static void Dump(SyntaxDefinition syntaxDefiniton, TextWriter writer)
{
ArgumentValidator.ThrowIfNull(syntaxDefiniton, "syntaxDefiniton");
ArgumentValidator.ThrowIfNull(writer, "writer");
foreach (SyntaxContext context in syntaxDefiniton.m_syntaxContexts) {
DoContext(context);
}
foreach (KeyValuePair<string, Cluster> pair in syntaxDefiniton.ClustersByName) {
Console.WriteLine("Cluster {0,-10} {1,-5} items Scope: {2}", pair.Key, pair.Value.CachedMemberItems.Items.Length, pair.Value.SyntaxContext.Name);
}
}
public Main()
{
InitializeComponent();
SyntaxDefinitionLoader sl = new SyntaxDefinitionLoader();
syntaxDefinition = sl.LoadXML(DEVotion.Properties.Resources.LUA.ToString());
LoadSettings();
tabDocs.OnClose += CloseTab;
tabDocs.OnAfterClose += AfterCloseTab;
UpdateButtons();
}
protected SyntaxDefinition LoadSyntax()
{
if (string.IsNullOrWhiteSpace(_SyntaxName))
{
return(null);
}
using Stream streamSyntax = Utils.GetEmbeddedResource(Assembly.GetAssembly(typeof(SpreadCommanderCommon)), $"SyntaxFiles.{_SyntaxName}.syn");
streamSyntax.Seek(0, SeekOrigin.Begin);
using StreamReader reader = new StreamReader(streamSyntax);
var syntax = SyntaxDefinition.FromSyntaxXml(reader.ReadToEnd());
return(syntax);
}
public SettingsForm(Plugin plugin)
{
InitializeComponent();
this.plugin = plugin;
variableTypeNames[typeof(CurrentTimeChannel).FullName] = "Current time";
variableTypeNames[typeof(RandomIntegerChannel).FullName] = "Random integer";
variableTypeNames[typeof(SawIntegerChannel).FullName] = "Saw (integer -100 .. 100)";
variableTypeNames[typeof(RampIntegerChannel).FullName] = "Ramp (integer 0 .. 100)";
variableTypeNames[typeof(SinusDoubleChannel).FullName] = "Sinus (double -1 .. 1)";
variableTypeNames[typeof(GenericChannel <int>).FullName] = "Simple integer";
variableTypeNames[typeof(GenericChannel <string>).FullName] = "Simple string";
variableTypeNames[typeof(GenericChannel <float>).FullName] = "Simple float";
variableTypeNames[typeof(ComputableChannel).FullName] = "Computable";
foreach (KeyValuePair <string, string> pair in variableTypeNames)
{
channelNames.Add(pair.Value);
}
grid.SelectionMode = SourceGrid.GridSelectionMode.Row;
grid.Selection.EnableMultiSelection = false;
DevAge.Drawing.RectangleBorder b = grid.Selection.Border;
b.SetWidth(0);
grid.Selection.Border = b;
grid.Selection.FocusBackColor = grid.Selection.BackColor;
grid.ColumnsCount = 3;
grid.RowsCount = 1;
grid[0, 0] = new SourceGrid.Cells.ColumnHeader("Channel name");
grid[0, 1] = new SourceGrid.Cells.ColumnHeader("Type");
grid[0, 2] = new SourceGrid.Cells.ColumnHeader("Read only");
string iPyFormatXML = (new StreamReader(new MemoryStream(global::FreeSCADA.Communication.SimulatorPlug.Resources.IronPython))).ReadToEnd();
SyntaxDefinition syntax = SyntaxDefinition.FromSyntaxXml(iPyFormatXML);
expressionEditBox.Document.Parser.Init(syntax);
grid.Selection.SelectionChanged += new SourceGrid.RangeRegionChangedEventHandler(OnSelectionChanged);
LoadChannels();
grid.AutoStretchColumnsToFitWidth = true;
grid.AutoSizeCells();
InitializeTooltips();
UpdateExpressionField();
}
public void CreateSyntaxDefinition()
{
TestHelper.Init();
this.m_syntaxDefinition = new SyntaxDefinition("unitTest");
SyntaxContext context = this.m_syntaxDefinition.MainContext;
this.m_syntaxDefinition.GetCluster("@cPreProcGroup", context).SetContentsTo("cUserLabel");
Region cDefine = new Region(context, "cDefine");
cDefine.Contains.SetContentsTo("ALLBUT,@CPreProcGroup,@Spell");
this.m_syntaxDefinition.AddHighlightLink("cDefine", "Macro");
cDefine.StartPatterns.Add(new Pattern("#define"));
cDefine.EndPatterns.Add(new Pattern("#end"));
new VimMatch(context, "cUserLabel", new Pattern(@"\w+"));
this.m_syntaxDefinition.AddHighlightLink("cUserLabel", "Label");
this.m_syntaxDefinition.FinishSyntaxDefinition();
}
public ScriptView(string scriptName) : base(new DummyDocument(scriptName))
{
this.script = Env.Current.ScriptManager.GetScript(scriptName);
InitializeComponent();
DocumentName = script.Name;
string iPyFormatXML = (new StreamReader(new MemoryStream(global::FreeSCADA.Designer.Resources.IronPython))).ReadToEnd();
SyntaxDefinition syntax = SyntaxDefinition.FromSyntaxXml(iPyFormatXML);
syntaxBoxControl.Document.Parser.Init(syntax);
syntaxBoxControl.Document.Text = script.Text;
IsModified = false;
script.TextUpdated += new EventHandler(OnScriptTextUpdated);
syntaxBoxControl.TextChanged += new System.EventHandler(this.syntaxBoxControl_TextChanged);
InitializeEditor();
InitializeCommands();
}
private void InitSyntaxDefinition()
{
bool gotLock = Monitor.TryEnter(this, TimeSpan.FromSeconds(20));
if (!gotLock)
{
string msg = StringExtensions.Fi("Thread {0} was waiting for the SyntaxDefinition for syntax '{1}' to be built by another thread, " +
"but after 20 seconds this is still not done. This may be due to excessive load on the computer or because of an Iris bug.",
ThreadExtensions.GetDescription(Thread.CurrentThread), this.Id);
throw new TimeoutException(msg);
}
try {
if (this.m_syntaxDefinition != null)
{
return;
}
this.m_syntaxDefinition = SyntaxLoader.BuildSyntaxDefinition(this.Id);
} finally {
Monitor.Exit(this);
}
}
private void InitSyntaxDefinition()
{
bool gotLock = Monitor.TryEnter(this, TimeSpan.FromSeconds(20));
if (!gotLock) {
string msg = StringExtensions.Fi("Thread {0} was waiting for the SyntaxDefinition for syntax '{1}' to be built by another thread, " +
"but after 20 seconds this is still not done. This may be due to excessive load on the computer or because of an Iris bug.",
ThreadExtensions.GetDescription(Thread.CurrentThread), this.Id);
throw new TimeoutException(msg);
}
try {
if (this.m_syntaxDefinition != null) {
return;
}
this.m_syntaxDefinition = SyntaxLoader.BuildSyntaxDefinition(this.Id);
} finally {
Monitor.Exit(this);
}
}
protected void DoWriteSyntaxText(string text, SyntaxName syntaxName, SyntaxTextOptions options)
{
options ??= new SyntaxTextOptions();
var book = options.Book?.Document ?? Document;
string strSyntax = null;
switch (syntaxName)
{
case SyntaxName.CSharp:
strSyntax = "C#";
break;
case SyntaxName.CPlusPlus:
strSyntax = "C++";
break;
case SyntaxName.Delphi:
strSyntax = "Delphi";
break;
case SyntaxName.DOSBatch:
strSyntax = "DOSBatch";
break;
case SyntaxName.FSharp:
strSyntax = "F#";
break;
case SyntaxName.Fortran90:
strSyntax = "Fortran90";
break;
case SyntaxName.Java:
strSyntax = "Java";
break;
case SyntaxName.JavaScript:
strSyntax = "JavaScript";
break;
case SyntaxName.LotusScript:
strSyntax = "LotusScript";
break;
case SyntaxName.MSIL:
strSyntax = "MSIL";
break;
case SyntaxName.Perl:
strSyntax = "Perl";
break;
case SyntaxName.PHP:
strSyntax = "PHP";
break;
case SyntaxName.PowerShell:
strSyntax = "PowerShell";
break;
case SyntaxName.Python:
strSyntax = "Python";
break;
case SyntaxName.R:
strSyntax = "R";
break;
case SyntaxName.SQL:
strSyntax = "SqlScript";
break;
case SyntaxName.VBNet:
strSyntax = "VB.Net";
break;
case SyntaxName.XML:
strSyntax = "XML";
break;
}
book.BeginUpdate();
try
{
string rtfText;
DocumentRange range;
if (!string.IsNullOrWhiteSpace(strSyntax))
{
using (var syntaxDocument = new SyntaxDocument())
{
SyntaxDefinition syntaxDefinition = LoadSyntax(strSyntax);
syntaxDocument.Parser.Init(syntaxDefinition);
syntaxDocument.ReParse();
syntaxDocument.Text = text;
rtfText = syntaxDocument.ExportToRTF(null, "Lucida Console");
}
range = book.AppendRtfText(rtfText, InsertOptions.KeepSourceFormatting);
}
else
{
range = book.AppendText(text);
}
if (!string.IsNullOrWhiteSpace(options.ParagraphStyle))
{
var style = book.ParagraphStyles[options.ParagraphStyle] ?? throw new Exception($"Paragraph style '{options.ParagraphStyle}' does not exist.");
var pp = book.BeginUpdateParagraphs(range);
try
{
pp.Style = style;
}
finally
{
book.EndUpdateParagraphs(pp);
}
}
Script.Book.SCBook.AddComments(book, range, options);
WriteRangeToConsole(book, range);
if (range?.End != null)
{
book.CaretPosition = range.End;
Script.Book.SCBook.ResetBookFormatting(book, range.End);
ScrollToCaret();
}
}
finally
{
book.EndUpdate();
}
SyntaxDefinition LoadSyntax(string syntaxFileName)
{
if (string.IsNullOrWhiteSpace(syntaxFileName))
{
return(null);
}
using var streamSyntax = Utils.GetEmbeddedResource(System.Reflection.Assembly.GetAssembly(this.GetType()), $"SyntaxFiles.{syntaxFileName}.syn");
streamSyntax.Seek(0, SeekOrigin.Begin);
using var reader = new StreamReader(streamSyntax);
var syntax = SyntaxDefinition.FromSyntaxXml(reader.ReadToEnd());
return(syntax);
}
}
public void Init(string syntaxFile, string separators)
{
try
{
if (!syntaxFile.ToLowerInvariant().EndsWith(".syn"))
syntaxFile += ".syn";
SyntaxDefinition = new SyntaxDefinitionLoader().Load(syntaxFile, separators);
}
catch {}
}
/// <summary>
///
/// </summary>
/// <param name="SyntaxFile"></param>
public void Init(string SyntaxFile)
{
try
{
if (!SyntaxFile.ToLowerInvariant().EndsWith(".syn"))
SyntaxFile += ".syn";
SyntaxDefinition = new SyntaxDefinitionLoader().Load(SyntaxFile);
}
catch {}
}
/// <summary>
///
/// </summary>
public DefaultParser()
{
mSyntaxDefinition = null;
}
/// <summary>
///
/// </summary>
/// <param name="syntaxDefinition"></param>
public void Init(SyntaxDefinition syntaxDefinition)
{
SyntaxDefinition = syntaxDefinition;
}
/// <devdoc>
/// SHOULD: refactor. First off, we need to make these parsing rules static to speed things up. Secondly, this whole scanning needs to be fixed
/// up as these regexes are a bloody hack. This should tie in with full Vim script support.
/// </devdoc>
public VimScriptParser(FileInfo vimSyntaxFile, bool verifyRegexes)
{
ArgumentValidator.ThrowIfDoesNotExist(vimSyntaxFile, "vimSyntaxFile");
this.m_verifyRegexes = verifyRegexes;
this.m_syntaxDefinition = new SyntaxDefinition(Path.GetFileNameWithoutExtension(vimSyntaxFile.Name));
this.m_parseRules = new List<ParseRule>();
AddParsingRule(@"^ \s* $", SkipLine);
AddParsingRule(@"^ \s* """, SkipLine);
AddParsingRule(@"^ \s* :? sy(n|nt|nta|ntax)? \s+ case \s+ (?<caseSensitivity>ignore|match)", SetCaseSensitivity);
AddParsingRule(@"^ \s* :? sy(n|nt|nta|ntax)? \s+ keyword \s+ (?<keywordGroup>\S+) ( \s+ ((?<options> KeywordOptions) | (?<keyword> \S+)) (?=\s|$) )+ ", this.AddKeywords);
AddParsingRule(@"^ \s* :? sy(n|nt|nta|ntax)? \s+ match \s+ (?<groupName>\S+) (\s+ (?<options> AllOptions))* \s+ Pattern (\s+ (?<options> AllOptions))* ", this.AddMatch);
AddParsingRule(@"^ \s* :? sy(n|nt|nta|ntax)? \s+ region \s+ (?<groupName>\S+) (\s+ (?<options> AllOptions|start EqualPattern|skip EqualPattern|end EqualPattern))*", this.AddRegion);
AddParsingRule(@"^ \s* :? sy(n|nt|nta|ntax)? \s+ cluster \s+ (?<clusterName>\S+) (\s+ (?<commands> add OptionArgument | remove OptionArgument | contains OptionArgument))*", this.AddCluster);
AddParsingRule(@"^ \s* :? sy(n|nt|nta|ntax)? \s+ include \s+ (?<targetCluster>@ \S+)? .* / (?<syntaxId> \S+ \.vim)", this.DoSyntaxImport);
AddParsingRule(@"^ \s* :? (runtime!? | (do)? au Syn) .* / (?<syntaxId> \S+ \.vim)", this.DoRunSyntax);
AddParsingRule(@"^ \s* :? if (\s+ | (?=\()) (?<condition>.*?) (?<endif>en(d|di|dif)?)? \s* $", this.ProcessIf);
AddParsingRule(@"^ \s* :? elseif? ( \s+ | (?=\() ) (?<condition>.*) $", this.ProcessElseIf);
AddParsingRule(@"^ \s* :? el(s|se)? \b", this.ProcessElse);
AddParsingRule(@"^ \s* :? en(d|di|dif)? \b", this.ProcessEndIf);
AddParsingRule(@"^ \s* :? (let | unl(e|et)?) .* $", this.Evaluate);
AddParsingRule(@"^ \s* :? (let | unl(e|et)?) .* $", this.Evaluate);
AddParsingRule(@"^ \s* (HiLink|hi!?\ (def\ )? link|SynLink|\w+HiLink|SynLink|hi\w+\ link) \s+ (?<itemName>\w+) \s+ (?<definition>\w+)", this.AdddHighlightingLink);
AddParsingRule(@"^ \s* (set(l|lo|loc|loca|local|) \s+ iskeyword (?<plus>\+)? = | SetIsk\s+) (?<charList>.+) $", this.SetKeywordChars);
this.m_ignoreCase = false;
this.m_evaluator.SetVariable("version", 700);
this.m_evaluator.SetVariable("v:version", 700);
this.m_evaluator.SetVariable("&cpo", "aABceFs");
this.m_evaluator.SetVariable("*AntSyntaxScript", 1);
this.m_evaluator.SetVariable("pascal_delphi", 1);
this.m_evaluator.SetVariable("g:mapleversion", 10);
this.m_evaluator.SetVariable("b:is_bash", 1);
this.m_evaluator.SetVariable("c_gnu", 1);
this.m_evaluator.SetVariable("g:vimsyntax_noerror", 1);
this.m_evaluator.SetVariable("g:vimembedscript", 0);
this.m_evaluator.SetVariable("php_htmlInstrings", 1);
this.m_evaluator.SetVariable("php_baselib", 1);
this.m_evaluator.SetVariable("php_asp_tags", 1);
this.m_evaluator.SetVariable("php_folding", 0);
this.m_evaluator.SetVariable("php_sync_method", 100);
foreach (FunctionTableEntry entry in m_evaluatorFunctions) {
this.m_evaluator.AddFunction(entry);
}
this.m_sourceFiles = new List<ScriptSourceFile>();
this.m_sourceFiles.Add(new ScriptSourceFile(vimSyntaxFile, this.m_syntaxDefinition.MainContext));
this.ParseFile();
}
protected void ApplyStyle()
{
if (IsDisposed)
{
return;
}
_InitialSyntaxDefinition = LoadSyntax();
var syntaxDefinition = LoadSyntax();
var skin = CommonSkins.GetSkin(UserLookAndFeel.Default);
var backColor = skin.TranslateColor(SystemColors.Window);
var foreColor = skin.TranslateColor(SystemColors.WindowText);
BackColor = backColor;
ForeColor = foreColor;
bool isSkinDark = FrameHelper.IsDarkSkin(UserLookAndFeel.Default);
if (syntaxDefinition != null)
{
foreach (var textStyle in syntaxDefinition.Styles)
{
if (textStyle.BackColor == Color.Transparent || textStyle.BackColor.ToArgb() == Color.Empty.ToArgb())
{
textStyle.BackColor = SystemColors.Window;
}
textStyle.BackColor = skin.TranslateColor(textStyle.BackColor);
//textStyle.BackColor = textStyle.BackColor != SystemColors.Window ? isSkinDark ? textStyle.BackColor.Invert() : textStyle.BackColor : backColor;
if (textStyle.ForeColor == Color.Transparent || textStyle.ForeColor.ToArgb() == Color.Empty.ToArgb())
{
textStyle.ForeColor = SystemColors.WindowText;
}
textStyle.ForeColor = skin.TranslateColor(textStyle.ForeColor);
//textStyle.ForeColor = textStyle.ForeColor != SystemColors.WindowText ? isSkinDark ? textStyle.ForeColor.Invert() : textStyle.ForeColor : foreColor;
}
}
BorderColor = skin.TranslateColor(_BorderColor);
BracketBackColor = skin.TranslateColor(_BracketBackColor);
BracketBorderColor = skin.TranslateColor(_BracketBorderColor);
BracketForeColor = skin.TranslateColor(_BracketForeColor);
BreakPointBackColor = skin.TranslateColor(_BreakPointBackColor);
BreakPointForeColor = skin.TranslateColor(_BreakPointForeColor);
ChildBorderColor = skin.TranslateColor(_ChildBorderColor);
EOLMarkerColor = skin.TranslateColor(_EOLMarkerColor);
GutterMarginBorderColor = skin.TranslateColor(_GutterMarginBorderColor);
GutterMarginColor = skin.TranslateColor(_GutterMarginColor);
HighLightedLineColor = skin.TranslateColor(_HighLightedLineColor);
InactiveSelectionBackColor = skin.TranslateColor(_InactiveSelectionBackColor);
InactiveSelectionForeColor = //skin.TranslateColor(Color.FromArgb(_InactiveSelectionForeColor.ToArgb()));
isSkinDark ? Color.White : Color.Black;
LineNumberBackColor = skin.TranslateColor(_LineNumberBackColor);
LineNumberBorderColor = skin.TranslateColor(_LineNumberBorderColor);
LineNumberForeColor = skin.TranslateColor(_LineNumberForeColor);
OutlineColor = skin.TranslateColor(_OutlineColor);
ScopeBackColor = skin.TranslateColor(_ScopeBackColor);
ScopeIndicatorColor = skin.TranslateColor(_ScopeIndicatorColor);
SelectionBackColor = skin.TranslateColor(_SelectionBackColor);
SelectionForeColor = skin.TranslateColor(_SelectionForeColor);
SeparatorColor = skin.TranslateColor(_SeparatorColor);
TabGuideColor = skin.TranslateColor(_TabGuideColor);
WhitespaceColor = skin.TranslateColor(_WhitespaceColor);
Word.DefaultErrorColor = skin.TranslateColor(Color.Red);
foreach (var view in Views)
{
view.TopThumb.BackColor = BorderColor;
view.LeftThumb.BackColor = BorderColor;
view.FillerBackColor = backColor;
}
SplitViewBackColor = skin.TranslateColor(Color.FromArgb((isSkinDark ? SystemColors.ControlDarkDark : SystemColors.ControlLightLight).ToArgb()));
bool modified = Document.Modified;
try
{
if (syntaxDefinition != null)
{
Document.Parser.Init(syntaxDefinition);
}
else
{
Document.Parser.SyntaxDefinition = null;
}
Document.ReParse();
}
finally
{
Document.Modified = modified;
}
}
public TextEditor(string filename)
{
BackColor = Color.FromArgb(255, 34, 40, 42);
//find the syntax definition
p_SyntaxDefinition = null;
string syntaxName = new FileInfo(filename).Extension.Replace(".", "").ToLower();
for (int c = 0; c < p_SyntaxNames.Length; c++)
{
if (p_SyntaxNames[c] == syntaxName)
{
p_SyntaxDefinition = p_SyntaxDefinitions[c];
break;
}
}
//default to a unknown syntax definition if the file extension
//isn't known.
if (p_SyntaxDefinition == null)
{
for (int c = 0; c < p_SyntaxNames.Length; c++)
{
if (p_SyntaxNames[c] == "unknown")
{
p_SyntaxDefinition = p_SyntaxDefinitions[c];
break;
}
}
}
//create the syntaxbox control
p_Base = new SyntaxBoxControl()
{
Dock = DockStyle.Fill,
BackColor = BackColor,
BracketBackColor = Color.Transparent,
BracketForeColor = Color.White,
BracketBorderColor = Color.FromArgb(255, 60, 70, 70),
ShowLineNumbers = false,
ShowGutterMargin = false,
SplitView = false,
FontName = "Consolas",
FontSize = 10
};
p_Base.Document = new SyntaxDocument();
p_Base.Document.Parser.Init(p_SyntaxDefinition);
p_Base.Document.Text = File.ReadAllText(filename);
p_Base.Document.Change += delegate(object sender, EventArgs e) {
if (Modified == null)
{
return;
}
Modified(this, e);
};
//create the right click menu
ContextMenuStrip rightClickMenu = new ContextMenuStrip();
rightClickMenu.Opening += delegate(object sender, System.ComponentModel.CancelEventArgs e) {
presentRightClickMenu(rightClickMenu);
};
ContextMenuStrip = rightClickMenu;
//add the control
Controls.Add(p_Base);
}
/// <summary>
///
/// </summary>
public DefaultParser()
{
mSyntaxDefinition = null;
}
/// <summary>
///
/// </summary>
/// <param name="syntaxDefinition"></param>
public void Init(SyntaxDefinition syntaxDefinition)
{
SyntaxDefinition = syntaxDefinition;
}
/// <summary>
/// Default spanDefinition constructor
/// </summary>
public SpanDefinition(SyntaxDefinition parent) : this()
{
Parent = parent;
Parent.ChangeVersion();
}
