public bool Compile(SquirrelVersion sv, string src, ref SQCompileError err)
{
/*if (sv == SquirrelVersion.Squirrel2)
* {
* Squirrel.Squirrel2.CompilerError cr = null;
* if (!c2.Compile(src, ref cr))
* {
* err = new SQCompileError();
* err.column = cr.column;
* err.line = cr.line;
* err.error = cr.error;
* return false;
* }
* return true;
* }*/
if (sv == SquirrelVersion.Squirrel3)
{
Squirrel.Squirrel3.CompilerError cr = null;
if (!c3.Compile(src, ref cr))
{
err = new SQCompileError();
err.column = cr.column;
err.line = cr.line;
err.error = cr.error;
return(false);
}
return(true);
}
err = new SQCompileError();
err.error = "invalid language version selected";
return(false);
}
public bool Compile(ITextBuffer buffer, ref SQCompileError error)
{
bool result = _instance.Compile(buffer.CurrentSnapshot.GetText(), ref error);
string filepath = SQLanguageServiceEX.GetFileName(buffer);
RegisterError(true, null, filepath, ref error);
return(result);
}
public void Parse()
{
string[] freshfiles;
var buffers = GetLoadedBuffers(out freshfiles);
foreach (var buffer in buffers)
{
bool newversion;
Parse(buffer, out newversion);
}
foreach (var file in freshfiles)
{
if (File.Exists(file))
{
SQCompileError e = null;
Parse(file);
}
}
}
public IEnumerable <ITagSpan <ErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
ITextSnapshot currentSnapshot = _buffer.CurrentSnapshot;
SQCompileError error = null;
if (firsttime)
{
_languangeService.Compile(_buffer, ref error);
firsttime = false;
}
else
{
error = _languangeService.GetError(filepath);
}
if (error != null)
{
SnapshotSpan?span = null;
try
{
ITextSnapshot shot = _buffer.CurrentSnapshot;
ITextSnapshotLine line = shot.GetLineFromLineNumber(error.line - 1);
int c = error.column - 1;
int length = Math.Max(line.Length - c, 1);
int startadd = Math.Min(line.Length, c);
span = new SnapshotSpan(line.Start + startadd, length);
}
catch (Exception)
{
}
if (span != null)
{
// if (ForceNewVersion)
// TagsChanged(this, new SnapshotSpanEventArgs(span.Value));
yield return(new TagSpan <ErrorTag>(span.Value, new ErrorTag("Error", error.error)));
}
}
ForceNewVersion = false;
}
void RegisterError(bool isnewversion, SQDeclaration d, string filepath, ref SQCompileError error)
{
if (isnewversion)
{
RemoveNodesWithFilepath(filepath);
_nodeErrors.Remove(filepath);
if (error != null)
{
_nodeErrors[filepath] = error;
}
_errorHandler.RemoveMessageWithPartialKey(filepath);
//RemoveNodesWithFilepath(filepath);
//MapObjects(GetNode(filepath), d);
}
_nodeErrors.TryGetValue(filepath, out error);
if (isnewversion && error != null)
{
TextSpan ts = new TextSpan();
ts.iStartLine = ts.iEndLine = error.line - 1;
ts.iStartIndex = error.column - 1;
string key = GenerateMessageKey(filepath, ts);
CompleteErrorEvent func = new CompleteErrorEvent((e) =>
{
e.Line = ts.iStartLine;
e.Column = ts.iStartIndex;
e.Document = filepath;
e.HierarchyItem = GetNode(filepath);
int length = ts.iEndIndex - ts.iStartIndex;
e.Navigate += (s, ee) =>
{
SQVSUtils.OpenDocumentInNewWindow(filepath, _serviceProvider, ts.iStartLine, ts.iStartIndex, 1);
};
});
_errorHandler.PostMessage(TaskErrorCategory.Error, TaskCategory.CodeSense, func, false, key, error.error);
}
}
//int lastVersion = -1;
public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (spans.Count == 0)
{
yield break;
}
ITextSnapshot currentSnapshot = _buffer.CurrentSnapshot;
SQCompileError error = null;
bool newversion;
_languangeService.Parse(_buffer, out newversion, ref error);
var ts = _languangeService.GetClassificationInfo(filepath);
// int currentVersion = _buffer.CurrentSnapshot.Version.VersionNumber;
List <SnapshotSpan> keywordspans = new List <SnapshotSpan>();
List <SnapshotSpan> nokeywordspans = new List <SnapshotSpan>();
List <TagSpan <ClassificationTag> > _currentTags = new List <TagSpan <ClassificationTag> >();
var cachekeys = _languangeService.GetKeywordSpans(filepath);
if (cachekeys == null || newversion)
{
//_currentTags.Clear();
var textstructnav = _textStructureNavigatorSelector.GetTextStructureNavigator(_buffer);
FindData fd = new FindData();
fd.TextStructureNavigator = textstructnav;
fd.FindOptions = FindOptions.WholeWord | FindOptions.MatchCase;
foreach (SnapshotSpan curSpan in spans)
{
fd.TextSnapshotToSearch = curSpan.Snapshot;
foreach (string key in _sqTypes.Keys)
{
fd.SearchString = key;
var result = _textSearchService.FindAll(fd);
keywordspans.AddRange(result);
}
}
_languangeService.SetKeywordCache(filepath, keywordspans.ToArray());
}
else
{
keywordspans.AddRange(cachekeys);
}
foreach (var t in ts)
{
TextSpan scope = t.Item2;
if (t.Item4 == SQDeclarationType.Class ||
t.Item4 == SQDeclarationType.Enum)
{
scope = t.Item1;
}
if (scope.iEndLine == -1 || scope.iStartLine == -1 ||
scope.iEndLine >= currentSnapshot.LineCount || scope.iStartLine >= currentSnapshot.LineCount)
{
continue;
}
int length = 0;
string collpasedlabel = t.Item3;
SnapshotPoint?start = null;
try
{
var startLine = currentSnapshot.GetLineFromLineNumber(scope.iStartLine);
var endLine = currentSnapshot.GetLineFromLineNumber(scope.iEndLine);
start = startLine.Start + scope.iStartIndex;
length = (endLine.Start - startLine.Start) + scope.iEndIndex - scope.iStartIndex;
if (start.Value.Position + length >= currentSnapshot.Length)
{
length = currentSnapshot.Length - start.Value.Position;
}
}
catch (Exception)
{
length = 0;
}
if (length > 0 && start != null)
{
SnapshotSpan snap = new SnapshotSpan(start.Value, length);
if (newversion)
{
TagsChanged(this, new SnapshotSpanEventArgs(snap));
}
switch (t.Item4)
{
case SQDeclarationType.AttributeScope:
nokeywordspans.Add(snap);
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _attribtag));
break;
case SQDeclarationType.CommentScope:
nokeywordspans.Add(snap);
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _commenttag));
break;
case SQDeclarationType.LiteralScope:
nokeywordspans.Add(snap);
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _stringtag));
break;
case SQDeclarationType.Extend:
case SQDeclarationType.Class:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _classtag));
break;
case SQDeclarationType.Enum:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _enumtag));
break;
case SQDeclarationType.SubName:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _subnametag));
break;
case SQDeclarationType.Number:
_currentTags.Add(new TagSpan <ClassificationTag>(snap, _numberictag));
break;
}
}
}
foreach (var kwspan in keywordspans)
{
bool cancel = false;
foreach (var nokwspan in nokeywordspans)
{
if (nokwspan.Contains(kwspan.Start.Position))//nokwspan.IntersectsWith(kwspan))
{
cancel = true;
break;
}
}
if (cancel)
{
continue;
}
if (newversion)
{
TagsChanged(this, new SnapshotSpanEventArgs(kwspan));
}
_currentTags.Add(new TagSpan <ClassificationTag>(kwspan, _keywordtag));
}
foreach (var t in _currentTags)
{
yield return(t);
}
}
public bool Compile(string src, ref SQCompileError error)
{
return(_compiler.Compile(_version, src, ref error));
}
