public override void Init(GrammarData grammarData) {
base.Init(grammarData);
if (Terminator == null)
_terminators = new char[] { '\n', '\r'};
else
_terminators = new char[] { Terminator[0]};
}
public LanguageData(Grammar grammar) {
Grammar = grammar;
GrammarData = new GrammarData(this);
ParserData = new ParserData(this);
ScannerData = new ScannerData(this);
ConstructAll();
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
string workPattern = @"\G(" + Pattern + ")";
RegexOptions options = (Grammar.CaseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase);
_expression = new Regex(workPattern, options);
if (this.EditorInfo == null)
this.EditorInfo = new TokenEditorInfo(TokenType.Unknown, TokenColor.Text, TokenTriggers.None);
}
public IndentFilter(GrammarData grammarData, KeyTerm lineContinuation, KeyTerm bracket_open, KeyTerm bracket_close)
{
this.grammarData = grammarData;
grammar = grammarData.Grammar;
grammar.LanguageFlags |= LanguageFlags.EmitLineStartToken;
opening_bracket = bracket_open;
closing_bracket = bracket_close;
}
public override void Init(GrammarData grammarData)
{
base.Init(grammarData);
if (this.EditorInfo == null)
{
this.EditorInfo = new TokenEditorInfo(TokenType.Comment, TokenColor.Comment, TokenTriggers.None);
}
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
var stopChars = new CharHashSet();
foreach (var key in Escapes.Keys)
stopChars.Add(key[0]);
foreach (var t in Terminators)
stopChars.Add(t[0]);
_stopChars = stopChars.ToArray();
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
// initialize string of start characters for fast lookup
_startSymbolsFirsts = new String(StartSymbols.Select(s => s.First()).ToArray());
if (this.EditorInfo == null) {
this.EditorInfo = new TokenEditorInfo(TokenType.Delimiter, TokenColor.Comment, TokenTriggers.None);
}
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
if (!string.IsNullOrEmpty(HtmlElementName)) {
if (string.IsNullOrEmpty(OpenHtmlTag)) OpenHtmlTag = "<" + HtmlElementName + ">";
if (string.IsNullOrEmpty(CloseHtmlTag)) CloseHtmlTag = "</" + HtmlElementName + ">";
}
if (!string.IsNullOrEmpty(ContainerHtmlElementName)) {
if (string.IsNullOrEmpty(ContainerOpenHtmlTag)) ContainerOpenHtmlTag = "<" + ContainerHtmlElementName + ">";
if (string.IsNullOrEmpty(ContainerCloseHtmlTag)) ContainerCloseHtmlTag = "</" + ContainerHtmlElementName + ">";
}
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
// convert strings to terminals, if needed
_firstTerminal = _firstTerminal ?? Grammar.ToTerm(_firstString);
if (_beforeStrings.Count > 0) {
//SL pukes here, it does not support co/contravariance in full, we have to do it long way
foreach (var s in _beforeStrings)
_beforeTerminals.Add(Grammar.ToTerm(s));
}
//Build description
var beforeTerms = string.Join(" ", _beforeTerminals.Select(t => t.Name));
_description = string.Format("{0} if {1} comes before {2}.", _actionType, _firstTerminal.Name, beforeTerms);
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
var stopCharSet = new CharHashSet();
foreach(var term in grammarData.Terminals) {
var firsts = term.GetFirsts();
if (firsts == null) continue;
foreach (var first in firsts)
if (!string.IsNullOrEmpty(first))
stopCharSet.Add(first[0]);
}//foreach term
if (EscapeChar != NoEscape)
stopCharSet.Add(EscapeChar);
_stopChars = stopCharSet.ToArray();
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
_isSimple = Terminators.Count == 1 && Escapes.Count == 0;
if (_isSimple) {
_singleTerminator = Terminators.First();
return;
}
var stopChars = new CharHashSet();
foreach (var key in Escapes.Keys)
stopChars.Add(key[0]);
foreach (var t in Terminators)
stopChars.Add(t[0]);
_stopChars = stopChars.ToArray();
}
public CodeOutlineFilter(GrammarData grammarData, OutlineOptions options, KeyTerm continuationTerminal) {
_grammarData = grammarData;
_grammar = grammarData.Grammar;
_grammar.LanguageFlags |= LanguageFlags.EmitLineStartToken;
Options = options;
ContinuationTerminal = continuationTerminal;
if (ContinuationTerminal != null)
if (!_grammar.NonGrammarTerminals.Contains(ContinuationTerminal))
_grammarData.Language.Errors.Add(GrammarErrorLevel.Warning, null, Resources.ErrOutlineFilterContSymbol, ContinuationTerminal.Name);
//"CodeOutlineFilter: line continuation symbol '{0}' should be added to Grammar.NonGrammarTerminals list.",
_produceIndents = OptionIsSet(OutlineOptions.ProduceIndents);
_checkBraces = OptionIsSet(OutlineOptions.CheckBraces);
_checkOperator = OptionIsSet(OutlineOptions.CheckOperator);
Reset();
}
private bool _isLineComment; //true if NewLine is one of EndSymbols; if yes, EOF is also considered a valid end symbol
#region overrides
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
//_endSymbolsFirsts char array is used for fast search for end symbols using String's method IndexOfAny(...)
_endSymbolsFirsts = new char[EndSymbols.Count];
for (int i = 0; i < EndSymbols.Count; i++) {
string sym = EndSymbols[i];
_endSymbolsFirsts[i] = sym[0];
_isLineComment |= sym.Contains("\n");
if (!_isLineComment)
SetFlag(TermFlags.IsMultiline);
}
if (this.EditorInfo == null) {
TokenType ttype = _isLineComment ? TokenType.LineComment : TokenType.Comment;
this.EditorInfo = new TokenEditorInfo(ttype, TokenColor.Comment, TokenTriggers.None);
}
}
string _suffixesFirsts; //first chars of all suffixes, for fast suffix detection
#endregion
#region overrides: Init, TryMatch
public override void Init(GrammarData grammarData)
{
base.Init(grammarData);
//collect all suffixes, prefixes in lists and create strings of first chars for both
Prefixes.Sort(StringList.LongerFirst);
_prefixesFirsts = string.Empty;
foreach (string pfx in Prefixes)
{
_prefixesFirsts += pfx[0];
}
Suffixes.Sort(StringList.LongerFirst);
_suffixesFirsts = string.Empty;
foreach (string sfx in Suffixes)
{
_suffixesFirsts += sfx[0]; //we don't care if there are repetitions
}
if (!CaseSensitive)
{
_prefixesFirsts = _prefixesFirsts.ToLower() + _prefixesFirsts.ToUpper();
_suffixesFirsts = _suffixesFirsts.ToLower() + _suffixesFirsts.ToUpper();
}
}//method
public readonly UnicodeCategoryList CharsToRemoveCategories = new UnicodeCategoryList(); //categories of chars to remove from final id, usually formatting category
#endregion
#region overrides
public override void Init(GrammarData grammarData)
{
base.Init(grammarData);
_allCharsSet = new CharHashSet(Grammar.CaseSensitive);
_allCharsSet.UnionWith(AllChars.ToCharArray());
//Adjust case restriction. We adjust only first chars; if first char is ok, we will scan the rest without restriction
// and then check casing for entire identifier
switch (CaseRestriction)
{
case CaseRestriction.AllLower:
case CaseRestriction.FirstLower:
_allFirstCharsSet = new CharHashSet(true);
_allFirstCharsSet.UnionWith(AllFirstChars.ToLowerInvariant().ToCharArray());
break;
case CaseRestriction.AllUpper:
case CaseRestriction.FirstUpper:
_allFirstCharsSet = new CharHashSet(true);
_allFirstCharsSet.UnionWith(AllFirstChars.ToUpperInvariant().ToCharArray());
break;
default: //None
_allFirstCharsSet = new CharHashSet(Grammar.CaseSensitive);
_allFirstCharsSet.UnionWith(AllFirstChars.ToCharArray());
break;
}
//if there are "first" chars defined by categories, add the terminal to FallbackTerminals
if (this.StartCharCategories.Count > 0)
{
grammarData.NoPrefixTerminals.Add(this);
}
if (this.EditorInfo == null)
{
this.EditorInfo = new TokenEditorInfo(TokenType.Identifier, TokenColor.Identifier, TokenTriggers.None);
}
}
public virtual void Initialize(GrammarData grammarData)
{
_grammarData = grammarData;
}
public override void Initialize(GrammarData grammarData)
{
base.Initialize(grammarData);
}
public override void Init(GrammarData grammarData)
{
base.Init(grammarData);
Grammar.UsesNewLine = true; //That will prevent SkipWhitespace method from skipping new-line chars
}
public override void Initialize(GrammarData grammarData)
{
base.Initialize(grammarData);
_startSymbolsFirsts = new CharHashSet(CaseSensitivePrefixesSuffixes);
if (_subTypes.Count == 0)
{
//"Error in heredoc literal [{0}]: No start/end symbols specified."
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrInvHereDocDef, Name);
return;
}
MergeSubTypes();
_subTypes.Sort(HereDocSubType.LongerStartFirst);
var quoteStrings = new StringSet(QuoteCaseSensitive ? StringComparer.InvariantCulture : StringComparer.InvariantCultureIgnoreCase);
foreach (var subType in _subTypes)
{
if (quoteStrings.Overlaps(subType.Quotes))
{
//"Duplicate start symbol {0} in heredoc literal [{1}]."
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrDupStartSymbolHereDoc, subType.Start, Name);
}
quoteStrings.UnionWith(subType.Quotes);
}
// Cases are merged, no need to check duplicated entries.
var isTemplate = false;
foreach (var subType in _subTypes)
{
_startSymbolsFirsts.Add(subType.Start[0]);
if ((subType.Flags & HereDocOptions.IsTemplate) != 0)
{
isTemplate = true;
}
}
// Always allow multiline.
SetFlag(TermFlags.IsMultiline);
if (isTemplate)
{
//Check that template settings object is provided
var templateSettings = AstConfig.Data as StringTemplateSettings;
if (templateSettings == null)
{
//"Error in string literal [{0}]: IsTemplate flag is set, but TemplateSettings is not provided."
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplNoSettings, Name);
}
else if (templateSettings.ExpressionRoot == null)
{
//""
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplMissingExprRoot, Name);
}
else if (!Grammar.SnippetRoots.Contains(templateSettings.ExpressionRoot))
{
//""
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplExprNotRoot, Name);
}
}
//Create editor info
if (EditorInfo == null)
{
EditorInfo = new TokenEditorInfo(TokenType.String, TokenColor.String, TokenTriggers.None);
}
}
public override void Initialize(GrammarData grammarData)
{
base.Initialize(grammarData);
_stopChars = new[] { EndSymbol, '\r', '\n' };
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
Grammar.UsesNewLine = true; //That will prevent SkipWhitespace method from skipping new-line chars
}
public override void Initialize(GrammarData grammarData)
{
base.Initialize(grammarData);
_startSymbolsFirsts = new CharHashSet(CaseSensitivePrefixesSuffixes);
if (_subtypes.Count == 0)
{
//"Error in string literal [{0}]: No start/end symbols specified."
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrInvStrDef, Name);
return;
}
//collect all start-end symbols in lists and create strings of first chars
var allStartSymbols = new StringSet(); //to detect duplicate start symbols
_subtypes.Sort(StringSubType.LongerStartFirst);
var isTemplate = false;
foreach (var subType in _subtypes)
{
if (allStartSymbols.Contains(subType.Start))
{
//"Duplicate start symbol {0} in string literal [{1}]."
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrDupStartSymbolStr, subType.Start, Name);
}
allStartSymbols.Add(subType.Start);
_startSymbolsFirsts.Add(subType.Start[0]);
if ((subType.Flags & StringOptions.IsTemplate) != 0)
{
isTemplate = true;
}
}
//Set multiline flag
if (_subtypes.Any(info => (info.Flags & StringOptions.AllowsLineBreak) != 0))
{
SetFlag(TermFlags.IsMultiline);
}
//For templates only
if (isTemplate)
{
//Check that template settings object is provided
var templateSettings = AstConfig.Data as StringTemplateSettings;
if (templateSettings == null)
{
//"Error in string literal [{0}]: IsTemplate flag is set, but TemplateSettings is not provided."
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplNoSettings, Name);
}
else if (templateSettings.ExpressionRoot == null)
{
//""
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplMissingExprRoot, Name);
}
else if (!Grammar.SnippetRoots.Contains(templateSettings.ExpressionRoot))
{
//""
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplExprNotRoot, Name);
}
}
//Create editor info
if (EditorInfo == null)
{
EditorInfo = new TokenEditorInfo(TokenType.String, TokenColor.String, TokenTriggers.None);
}
}
public override void Init(GrammarData grammarData) {
base.Init(grammarData);
//Remove new line chars from whitespace
foreach(char t in LineTerminators)
grammarData.Grammar.WhitespaceChars = grammarData.Grammar.WhitespaceChars.Replace(t.ToString(), string.Empty);
}
public override void Init(GrammarData grammarData)
{
base.Init(grammarData);
}
public virtual void Init(GrammarData grammarData)
{
GrammarData = grammarData;
}
string _startSymbolsFirsts; //first chars of start-end symbols
#endregion
#region overrides: Init, GetFirsts, ReadBody, etc...
public override void Init(GrammarData grammarData)
{
base.Init(grammarData);
_startSymbolsFirsts = string.Empty;
if (_subtypes.Count == 0)
{
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrInvStrDef, this.Name); //"Error in string literal [{0}]: No start/end symbols specified."
return;
}
//collect all start-end symbols in lists and create strings of first chars
var allStartSymbols = new StringSet(); //to detect duplicate start symbols
_subtypes.Sort(StringSubType.LongerStartFirst);
bool isTemplate = false;
foreach (StringSubType subType in _subtypes)
{
if (allStartSymbols.Contains(subType.Start))
{
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null,
Resources.ErrDupStartSymbolStr, subType.Start, this.Name); //"Duplicate start symbol {0} in string literal [{1}]."
}
allStartSymbols.Add(subType.Start);
_startSymbolsFirsts += subType.Start[0].ToString();
if ((subType.Flags & StringOptions.IsTemplate) != 0)
{
isTemplate = true;
}
}
if (!CaseSensitive)
{
_startSymbolsFirsts = _startSymbolsFirsts.ToLower() + _startSymbolsFirsts.ToUpper();
}
//Set multiline flag
foreach (StringSubType info in _subtypes)
{
if ((info.Flags & StringOptions.AllowsLineBreak) != 0)
{
SetFlag(TermFlags.IsMultiline);
break;
}
}
//For templates only
if (isTemplate)
{
//Check that template settings object is provided
var templateSettings = this.AstNodeConfig as StringTemplateSettings;
if (templateSettings == null)
{
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplNoSettings, this.Name); //"Error in string literal [{0}]: IsTemplate flag is set, but TemplateSettings is not provided."
}
else if (templateSettings.ExpressionRoot == null)
{
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplMissingExprRoot, this.Name); //""
}
else if (!Grammar.SnippetRoots.Contains(templateSettings.ExpressionRoot))
{
grammarData.Language.Errors.Add(GrammarErrorLevel.Error, null, Resources.ErrTemplExprNotRoot, this.Name); //""
}
}//if
//Create editor info
if (this.EditorInfo == null)
{
this.EditorInfo = new TokenEditorInfo(TokenType.String, TokenColor.String, TokenTriggers.None);
}
}//method
public override void Init(GrammarData grammarData)
{
base.Init(grammarData);
if (nextGrammarHint != null)
nextGrammarHint.Init(grammarData);
}
