internal ExpressionEval(ILanguageDefinition languageDefinition)
{
languageDefinition = languageDefinition ?? throw new ArgumentNullException(nameof(languageDefinition));
LanguageDefinition = languageDefinition;
Lexer = new Lexer(LanguageDefinition);
Parser = new Parser(LanguageDefinition);
}
internal static object?CallMethod <TScope, TRootScope>(ILanguageDefinition languageDefinition, ScopeStack <TScope, TRootScope> scopeStack, object?left, object?[] args)
where TScope : class, IScope
where TRootScope : class, TScope
{
switch (left)
{
case FunctionMethodGroup methodGroup:
return(methodGroup.FunctionDefinition.Invoke(languageDefinition, args));
case UserDefinedFunction userDefinedFunction:
return(userDefinedFunction.Invoke(languageDefinition, args));
case PipelineMethodGroup pipelineGroup:
return(pipelineGroup.FunctionDefinition.Invoke(languageDefinition, pipelineGroup.ReferredObject, args));
case ScopedFunctionMethodGroup scopedMethodGroup:
return(scopedMethodGroup.FunctionDefinition.Invoke(languageDefinition, scopeStack.Current, args));
default:
var callable = ReflectionHelpers.GetCallable(left);
if (callable != null)
{
return(callable.Invoke(left, new object[] { args }));
}
throw new NotImplementedException();
}
public Lexer(ILanguageDefinition pLanguageDefinition)
{
mlstDefinitions = new List <TokenDefinition>();
mdctPrecedence = new Dictionary <TokenType, int>();
pLanguageDefinition.InitializeGrammar(this);
pLanguageDefinition.InitializeOperatorPrecedence(this);
}
private void SetLanguage(ILanguageDefinition languageDefinition)
{
if (languageDefinition == null)
{
_view.TextEditor.SyntaxHighlighting = null;
}
else
{
_view.TextEditor.SyntaxHighlighting = languageDefinition.SyntaxHighlighting;
}
}
internal Parser(ILanguageDefinition languageDefinition, byte minimumLookahead = 1, byte minimumLookbehind = 1)
{
LanguageDefinition = languageDefinition;
_PrecedenceGroups = LanguageDefinition.Operators
.Where(op => !(op is MethodOperatorDefinition))
.GroupBy(op => op.Precedence)
.OrderBy(grp => grp.Key)
.ToArray();
_ValidOperatorTextValues = _PrecedenceGroups.Select(group => group.Select(op => op.Text).ToArray()).ToArray();
_LiteralParseDelegates = Array.Empty <TryParseDelegate>();
MinimumLookahead = Math.Max(minimumLookahead, (byte)1);
MinimumLookbehind = Math.Max(minimumLookbehind, (byte)1);
}
private void ApplyOriginalText()
{
_view.TextEditor.Text = _originalText;
_view.TextEditor.TextChanged += delegate
{
IsDirty = string.Compare(_originalText, _view.TextEditor.Text) != 0;
};
var fileExtension = Path.GetExtension(FileName).ToLower();
ILanguageDefinition languageDefinition = _languageDefinitionManager.GetDefinitionByExtension(fileExtension);
SetLanguage(languageDefinition);
}
internal Lexer(ILanguageDefinition languageDefinition)
{
LanguageDefinition = languageDefinition;
_Delegates = new TryReadDelegate[]
{
TryReadCharacterLiteral,
TryReadStringLiteral,
TryReadNumericLiteral,
TryReadWhiteSpace,
TryReadOperator,
TryReadIdentifier,
TryReadSingleChar,
};
_Operators = languageDefinition.Operators.ToDictionary(operatorDef => operatorDef.Text.ToCharArray());
_LookaheadCount = (byte)Math.Max(_Operators.Keys.Max(arr => arr.Length), _MIN_LOOKAHEAD_COUNT);
}
public LocalizedLanguage Import(ILanguageDefinition languageDefinition, IPluginConfig config)
{
var language = new LocalizedLanguage(languageDefinition);
var workbook = new XLWorkbook(language.Path);
var worksheet = workbook.Worksheet(1);
int headerRowsRemaining = config.GetInt("numberOfHeaderRows", 1);
int keyColumn = 1 + config.GetInt("keyColumn", 0);
int descriptionColumn = 1 + config.GetInt("descriptionColumn", 1);
int valueMasterColumn = 1 + config.GetInt("valueColumnForMaster", 2);
int valueNormalColumn = 1 + config.GetInt("valueColumnForNormal", 3);
bool isMasterLanguage = language.IsMasterLanguage;
int rowNumber = 1;
foreach (var row in worksheet.Rows())
{
if (headerRowsRemaining > 0)
{
headerRowsRemaining--;
rowNumber++;
continue;
}
if (row.IsEmpty())
{
rowNumber++;
continue;
}
int valueColumn = language.IsMasterLanguage ? valueMasterColumn : valueNormalColumn;
language.AddText(
key: row.Cell(keyColumn).Value.ToString(),
description: row.Cell(descriptionColumn).Value.ToString(),
value: row.Cell(valueColumn).Value.ToString(),
rowNumber: rowNumber);
rowNumber++;
}
return(language);
}
protected override void OnViewLoaded(object view)
{
using (var stream = File.OpenText(_path))
_originalText = stream.ReadToEnd();
_view = (ICodeEditorView)view;
_view.TextEditor.Text = _originalText;
_view.TextEditor.TextChanged += delegate
{
IsDirty = string.Compare(_originalText, _view.TextEditor.Text) != 0;
};
var fileExtension = System.IO.Path.GetExtension(_fileName).ToLower();
ILanguageDefinition languageDefinition = _languageDefinitionManager.GetDefinitionByExtension(fileExtension);
SetLanguage(languageDefinition);
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
internal void Deserialize(XmlReader reader)
{
// This might fail if the working folder is not accessible. So, we will retry
// once after setting the working folder to the temp folder.
int retryCount = 0;
while (true)
{
try
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(LanguageDefinition));
m_LanguageDefinition = (LanguageDefinition)xmlSerializer.Deserialize(reader);
if (m_wsf != null)
{
m_LanguageDefinition.WritingSystem.WritingSystemFactory = m_wsf;
for (int i = 0; i < m_LanguageDefinition.CollationCount; i++)
{
m_LanguageDefinition.GetCollation(i).WritingSystemFactory = m_wsf;
}
}
bool success = (m_LanguageDefinition as LanguageDefinition).LoadDefaultICUValues();
break;
}
catch
{
if (retryCount++ >= 1)
{
break;
}
Directory.SetCurrentDirectory(Path.GetTempPath());
}
}
reader.Close();
// Capture the initial state of the new definition.
if (m_LanguageDefinition != null)
{
(m_LanguageDefinition as LanguageDefinition).FinishedInitializing();
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
internal void Deserialize(XmlReader reader)
{
// This might fail if the working folder is not accessible. So, we will retry
// once after setting the working folder to the temp folder.
int retryCount = 0;
while (true)
{
try
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(LanguageDefinition));
m_LanguageDefinition = (LanguageDefinition)xmlSerializer.Deserialize(reader);
if (m_wsf != null)
{
m_LanguageDefinition.WritingSystem.WritingSystemFactory = m_wsf;
for (int i = 0; i < m_LanguageDefinition.CollationCount; i++)
{
m_LanguageDefinition.GetCollation(i).WritingSystemFactory = m_wsf;
}
}
bool success = (m_LanguageDefinition as LanguageDefinition).LoadDefaultICUValues();
break;
}
catch
{
if (retryCount++ >= 1)
break;
Directory.SetCurrentDirectory(Path.GetTempPath());
}
}
reader.Close();
// Capture the initial state of the new definition.
if (m_LanguageDefinition != null)
(m_LanguageDefinition as LanguageDefinition).FinishedInitializing();
}
private List <ILanguageDefinition> Initialize()
{
// Create built in language definitions
var languageDefinitions = new List <ILanguageDefinition>
{
new DefaultLanguageDefinition("C#", new[] { ".cs" }),
new DefaultLanguageDefinition("JavaScript", new[] { ".js" }),
new DefaultLanguageDefinition("HTML", new[] { ".htm", ".html" }),
new DefaultLanguageDefinition("ASP/XHTML",
new[] { ".asp", ".aspx", ".asax", ".asmx", ".ascx", ".master" }),
new DefaultLanguageDefinition("Boo", new[] { ".boo" }),
new DefaultLanguageDefinition("Coco", new[] { ".atg" }),
new DefaultLanguageDefinition("CSS", new[] { ".css" }),
new DefaultLanguageDefinition("C++", new[] { ".c", ".h", ".cc", ".cpp", ".hpp" }),
new DefaultLanguageDefinition("Java", new[] { ".java" }),
new DefaultLanguageDefinition("Patch", new[] { ".patch", ".diff" }),
new DefaultLanguageDefinition("PowerShell", new[] { ".ps1", ".psm1", ".psd1" }),
new DefaultLanguageDefinition("PHP", new[] { ".php" }),
new DefaultLanguageDefinition("TeX", new[] { ".tex" }),
new DefaultLanguageDefinition("VBNET", new[] { ".vb" }),
new DefaultLanguageDefinition("XML", (".xml;.xsl;.xslt;.xsd;.manifest;.config;.addin;" +
".xshd;.wxs;.wxi;.wxl;.proj;.csproj;.vbproj;.ilproj;" +
".booproj;.build;.xfrm;.targets;.xaml;.xpt;" +
".xft;.map;.wsdl;.disco;.ps1xml;.nuspec").Split(';')),
new DefaultLanguageDefinition("MarkDown", new[] { ".md" }),
};
// Add imported definitions
foreach (ILanguageDefinition importedLanguage in IoC.GetAll <ILanguageDefinition>())
{
ILanguageDefinition defaultLanguage =
languageDefinitions.FirstOrDefault(
l => string.Equals(l.Name, importedLanguage.Name, StringComparison.InvariantCultureIgnoreCase));
if (defaultLanguage != null)
{
// Relace default language definition
languageDefinitions.Remove(defaultLanguage);
}
languageDefinitions.Add(importedLanguage);
}
// Scan SyntaxHighlighting folder for more languages
string path = Path.Combine(Directory.GetCurrentDirectory(), "SyntaxHighlighting");
if (!Directory.Exists(path))
{
return(languageDefinitions);
}
List <string> highlightingFiles = Directory.GetFiles(path, "*.xshd").ToList();
char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
Dictionary <string, ILanguageDefinition> definitions = languageDefinitions.ToDictionary(l =>
{
char[] nameChars = l.Name.ToCharArray();
nameChars = nameChars.Except(invalidFileNameChars).ToArray();
return(new string(nameChars));
}, l => l);
foreach (string highlightingFile in highlightingFiles)
{
string fileName = Path.GetFileNameWithoutExtension(highlightingFile);
if (string.IsNullOrEmpty(fileName))
{
continue;
}
ILanguageDefinition definition;
if (definitions.TryGetValue(fileName, out definition))
{
// Set custom highlighting file for existing language
definition.CustomSyntaxHighlightingFileName = highlightingFile;
}
else
{
try
{
XshdSyntaxDefinition syntaxDefinition;
using (var reader = new XmlTextReader(highlightingFile))
syntaxDefinition = HighlightingLoader.LoadXshd(reader);
// Create language based on highlighting file.
languageDefinitions.Add(new DefaultLanguageDefinition(syntaxDefinition));
}
catch
{
continue;
}
}
}
return(languageDefinitions);
}
public void SerializeAndDeserialize()
{
IWritingSystem ws = m_wsf.get_Engine("tl");
int wsIdTl = m_wsf.GetWsFromStr("tl");
ws.Locale = 13321;
ws.DefaultMonospace = "Courier New";
ws.DefaultSansSerif = "Arial";
ws.DefaultBodyFont = "Charis SIL";
ws.DefaultSerif = "Times New Roman";
ws.set_Name(m_wsIdEn, "Tagalog");
ws.set_Name(wsIdTl, "Tagalog");
ws.set_Abbr(m_wsIdEn, "TGL");
ICollation coll = CollationClass.Create();
coll.WinLCID = 1033;
coll.WinCollation = "Latin1_General_CI_AI";
coll.set_Name(m_wsIdEn, "Default Collation");
coll.WritingSystemFactory = m_wsf;
ws.set_Collation(0, coll);
LanguageDefinition langDef = new LanguageDefinition(ws);
langDef.BaseLocale = "en_US";
langDef.XmlWritingSystem.WritingSystem.IcuLocale = "tl";
langDef.LocaleName = "Tagalog";
langDef.LocaleScript = "";
langDef.LocaleCountry = "";
langDef.LocaleVariant = "";
langDef.XmlWritingSystem.WritingSystem.Locale = 13321;
langDef.CollationElements = "\"& B < ...";
langDef.ValidChars = "abcdefg";
langDef.LocaleResources = @"
zoneStrings {
{
'Europe/London',
'Greenwich Mean Time',
}
}" ;
CharDef[] charDefs = new CharDef[2];
charDefs[0] = new CharDef(0xF170, "COMBINING SNAKE BELOW;Mn;202;NSM;;;;");
charDefs[1] = new CharDef(0xF210, "LATIN SMALL LETTER P WITH STROKE;Ll;0;L;;;;");
langDef.PuaDefinitions = charDefs;
FileName[] fonts = new FileName[4];
fonts[0] = new FileName("arial.ttf");
fonts[1] = new FileName("arialbd.ttf");
fonts[2] = new FileName("ariali.ttf");
fonts[3] = new FileName("arialbi.ttf");
langDef.Fonts = fonts;
langDef.Keyboard = new FileName("Tagalog.kmx");
langDef.EncodingConverter = new EncodingConverter("SIL_IPA93.tec.vbs", "SIL-IPA93.tec");
string tmpFileName = Path.GetTempFileName();
langDef.Serialize(tmpFileName);
LanguageDefinitionFactory otherIcuWs = new LanguageDefinitionFactory();
LanguageDefinitionFactory.WritingSystemFactory = m_wsf;
otherIcuWs.Deserialize(tmpFileName);
ILanguageDefinition newLangDef = otherIcuWs.LanguageDefinition;
IWritingSystem deserializedWs = newLangDef.WritingSystem;
ICollation deserializedColl = newLangDef.GetCollation(0);
StreamReader reader = new StreamReader(tmpFileName);
string line = reader.ReadLine();
while (line != null)
{
Console.WriteLine(line);
line = reader.ReadLine();
}
reader.Close();
File.Delete(tmpFileName);
Assert.AreEqual(ws.Locale, deserializedWs.Locale);
Assert.AreEqual(ws.IcuLocale, deserializedWs.IcuLocale);
Assert.AreEqual(ws.DefaultSansSerif, deserializedWs.DefaultSansSerif);
Assert.AreEqual(ws.DefaultBodyFont, deserializedWs.DefaultBodyFont);
Assert.AreEqual(ws.get_Name(m_wsIdEn), deserializedWs.get_Name(m_wsIdEn));
Assert.AreEqual(coll.WinLCID, deserializedColl.WinLCID);
Assert.AreEqual(coll.WinCollation, deserializedColl.WinCollation);
// ENHANCE: Add ValidChars to the interface
// Assert.AreEqual(ws.ValidChars, deserializedWs.ValidChars);
Assert.AreEqual(coll.get_Name(m_wsIdEn), deserializedColl.get_Name(m_wsIdEn));
}
internal ExpressionEval(ILanguageDefinition languageDefinition, Lexer?lexer = null, Parser?parser = null)
{
LanguageDefinition = languageDefinition;
Lexer = lexer ?? new Lexer(LanguageDefinition);
Parser = parser ?? new Parser(LanguageDefinition);
}
private void SetLanguage(ILanguageDefinition languageDefinition)
{
_view.TextEditor.SyntaxHighlighting = (languageDefinition != null)
? languageDefinition.SyntaxHighlighting
: null;
}
public LocalizedLanguage(ILanguageDefinition definition)
{
this.definition = definition;
}
internal ExpressionTreeTransformer(ILanguageDefinition languageDefinition, CompiledScope scope)
{
LanguageDefinition = languageDefinition;
OperatorTransformer = new ExpressionTreeOperatorTransformer(this, languageDefinition);
Scopes.Push(scope);
}
private List <ILanguageDefinition> Initialize()
{
// Create built in language definitions
var languageDefinitions = new List <ILanguageDefinition>();
// Add imported definitions
foreach (ILanguageDefinition importedLanguage in IoC.GetAll <ILanguageDefinition>().Except(IoC.GetAll <ExcludeLanguageDefinition>().SelectMany(e => e.ExcludedLanguageDefinition)))
{
ILanguageDefinition defaultLanguage =
languageDefinitions.FirstOrDefault(
l => string.Equals(l.Name, importedLanguage.Name, StringComparison.InvariantCultureIgnoreCase));
if (defaultLanguage != null)
{
// Relace default language definition
languageDefinitions.Remove(defaultLanguage);
}
languageDefinitions.Add(importedLanguage);
}
// Scan SyntaxHighlighting folder for more languages
string path = Path.Combine(Directory.GetCurrentDirectory(), "SyntaxHighlighting");
if (!Directory.Exists(path))
{
return(languageDefinitions);
}
List <string> highlightingFiles = Directory.GetFiles(path, "*.xshd").ToList();
char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
Dictionary <string, ILanguageDefinition> definitions = languageDefinitions.ToDictionary(l =>
{
char[] nameChars = l.Name.ToCharArray();
nameChars = nameChars.Except(invalidFileNameChars).ToArray();
return(new string(nameChars));
}, l => l);
foreach (string highlightingFile in highlightingFiles)
{
string fileName = Path.GetFileNameWithoutExtension(highlightingFile);
if (string.IsNullOrEmpty(fileName))
{
continue;
}
ILanguageDefinition definition;
if (definitions.TryGetValue(fileName, out definition))
{
// Set custom highlighting file for existing language
definition.CustomSyntaxHighlightingFileName = highlightingFile;
}
else
{
try
{
XshdSyntaxDefinition syntaxDefinition;
using (var reader = new XmlTextReader(highlightingFile))
syntaxDefinition = HighlightingLoader.LoadXshd(reader);
// Create language based on highlighting file.
languageDefinitions.Add(new DefaultLanguageDefinition(syntaxDefinition));
}
catch
{
continue;
}
}
}
return(languageDefinitions);
}
public ExcludeLanguageDefinition(ILanguageDefinition defitionToExclude)
{
ExcludedLanguageDefinition = new[] { defitionToExclude };
}
private void SetLanguage(ILanguageDefinition languageDefinition)
{
_view.TextEditor.SyntaxHighlighting = (languageDefinition != null)
? languageDefinition.SyntaxHighlighting
: null;
}
private ILanguageDefinition InitializeBasic(IWritingSystem ws)
{
m_wsf = ws.WritingSystemFactory;
m_LanguageDefinition = new LanguageDefinition(ws);
return m_LanguageDefinition;
}
internal DynamicOperatorTransformer(ScopeStack <TScope, TRootScope> scopeStack, ILanguageDefinition languageDefinition, DynamicTransformer <TScope, TRootScope> nodeTransformer)
{
LanguageDefinition = languageDefinition;
NodeTransformer = nodeTransformer;
ScopeStack = scopeStack;
}
internal DynamicTransformer(ScopeStack <TScope, TRootScope> scopeStack, ILanguageDefinition languageDefinition)
{
LanguageDefinition = languageDefinition;
ScopeStack = scopeStack;
OperatorTransformer = new DynamicOperatorTransformer <TScope, TRootScope>(scopeStack, languageDefinition, this);
}
public static Parser Create(ILanguageDefinition pDefinition)
{
var lexer = new Lexer(pDefinition);
return(new Parser(lexer));
}
private void SetLanguage(ILanguageDefinition languageDefinition)
{
if (languageDefinition == null)
_view.TextEditor.SyntaxHighlighting = null;
else
_view.TextEditor.SyntaxHighlighting = languageDefinition.SyntaxHighlighting;
}
internal bool Invoke(ILanguageDefinition languageDefinition, object?pipelineObject, object?[] args)
{
return(Invoke(UserDefinedArgumentData.Create(languageDefinition, Declaration.Arguments.ToArrayWithoutInstantiation(), pipelineObject.YieldOne().Concat(args).ToArray())));
}
internal object?Invoke(ILanguageDefinition languageDefinition, IScope scope, object?[] args)
{
return(Invoke(scope, UserDefinedArgumentData.Create(languageDefinition, Declaration.Arguments.ToArrayWithoutInstantiation(), args)));
}
private ILanguageDefinition InitializeBasic(IWritingSystem ws)
{
m_wsf = ws.WritingSystemFactory;
m_LanguageDefinition = new LanguageDefinition(ws);
return(m_LanguageDefinition);
}
internal ExpressionTreeOperatorTransformer(INodeTransformVisitor <Expression> nodeTransformVisitor, ILanguageDefinition languageDefinition)
{
NodeTransformVisitor = nodeTransformVisitor;
LanguageDefinition = languageDefinition;
}
internal object?Invoke(ILanguageDefinition languageDefinition, object?[] args)
{
var argumentData = UserDefinedArgumentData.Create(languageDefinition, Declaration.Arguments.ToArrayWithoutInstantiation(), args);
return(Invoke(argumentData));
}
