public void InsertOrUpdate(FFDatabase db, CodeModel.FileStore store, CodeModel.CodeModel model)
{
if (_id != 0)
{
using (var cmd = db.CreateCommand("update file_ set modified = @modified, visible = @visible where rowid = @id"))
{
cmd.Parameters.AddWithValue("@id", _id);
cmd.Parameters.AddWithValue("@modified", _modified);
cmd.Parameters.AddWithValue("@visible", _visible ? 1 : 0);
cmd.ExecuteNonQuery();
}
}
else
{
using (var cmd = db.CreateCommand(
"insert into file_ (app_id, file_name, modified, visible) values (@app_id, @file_name, @modified, @visible);"
+ " select last_insert_rowid();"))
{
cmd.Parameters.AddWithValue("@app_id", _app.Id);
cmd.Parameters.AddWithValue("@file_name", _fileName);
cmd.Parameters.AddWithValue("@modified", _modified);
cmd.Parameters.AddWithValue("@visible", _visible ? 1 : 0);
_id = Convert.ToInt64(cmd.ExecuteScalar());
}
}
UpdateIncludeDependencies(db, store, model);
}
private IEnumerable <ProbeSignature> GetSignatures(CodeModel.CodeModel model, int modelPos, string className, string funcName, VsText.ITrackingSpan applicableToSpan)
{
foreach (var sig in GetAllSignaturesForFunction(model, modelPos, className, funcName))
{
yield return(CreateSignature(_textBuffer, sig, applicableToSpan));
}
}
public IEnumerable <ITagSpan <ErrorTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
ThreadHelper.ThrowIfNotOnUIThread();
var appSettings = ProbeEnvironment.CurrentAppSettings;
var fileName = VsTextUtil.TryGetDocumentFileName(_view.TextBuffer);
_model = _store.GetMostRecentModel(appSettings, fileName, _view.TextSnapshot, "ErrorTagger.GetTags()");
return(ErrorTaskProvider.Instance.GetErrorTagsForFile(_model.FileName, spans));
}
public static IEnumerable <FunctionSignature> GetAllSignaturesForFunction(CodeModel.CodeModel model, int modelPos, string className, string funcName)
{
if (string.IsNullOrEmpty(className))
{
foreach (var def in model.DefinitionProvider.GetGlobalFromAnywhere <CodeModel.Definitions.FunctionDefinition>(funcName))
{
var funcDef = (def as CodeModel.Definitions.FunctionDefinition);
if (string.IsNullOrEmpty(funcDef.ClassName) || funcDef.ClassName == model.ClassName)
{
yield return(def.Signature);
}
}
}
else
{
foreach (var def in model.DefinitionProvider.GetGlobalFromAnywhere <CodeModel.Definitions.FunctionDefinition>(funcName))
{
if ((def as CodeModel.Definitions.FunctionDefinition).ClassName == className)
{
yield return(def.Signature);
yield break;
}
}
foreach (var def1 in model.DefinitionProvider.GetAny(modelPos, className))
{
if (def1 is CodeModel.Definitions.VariableDefinition)
{
var varDef = def1 as CodeModel.Definitions.VariableDefinition;
var dataType = varDef.DataType;
foreach (var opt in dataType.CompletionOptions)
{
if (opt.ArgumentsRequired)
{
yield return(opt.ArgumentsSignature);
}
}
}
}
}
}
public void SetSource(string source, int offset, VsText.ITextSnapshot snapshot, CodeModel.CodeModel model)
{
_source = source;
_pos = 0;
_posOffset = offset;
_length = _source.Length;
_snapshot = snapshot;
_model = model;
var transStart = snapshot.TranslateOffsetToSnapshot(offset, _model.Snapshot);
var transEnd = snapshot.TranslateOffsetToSnapshot(offset + source.Length, _model.Snapshot);
_tokenMap = new Dictionary <int, Token>();
foreach (var token in _model.File.FindDownward(transStart, transEnd - transStart))
{
var snapStart = _model.Snapshot.TranslateOffsetToSnapshot(token.Span.Start, snapshot);
_tokenMap[snapStart] = token;
}
}
private void ProcessFunctionFile(FunctionFileApp app, string fileName)
{
try
{
if (!File.Exists(fileName)) return;
DateTime modified;
if (!app.TryGetFileDate(fileName, out modified)) modified = DateTime.MinValue;
if (modified == DateTime.MinValue || Math.Abs(File.GetLastWriteTime(fileName).Subtract(modified).TotalSeconds) >= 1.0)
{
var merger = new FileMerger();
merger.MergeFile(fileName, false);
var fileTitle = Path.GetFileNameWithoutExtension(fileName);
var model = new CodeModel.CodeModel(merger.MergedContent, fileName);
var funcs = (from f in model.FunctionSignatures
where string.Equals(f.Name, fileTitle, StringComparison.OrdinalIgnoreCase)
select f).ToArray();
if (funcs.Length > 0)
{
foreach (var func in funcs)
{
app.AddFunction(func.Name, func.Signature);
}
}
else
{
app.RemoveFunctionIgnoreCase(fileTitle);
}
foreach (var fn in merger.FileNames)
{
app.UpdateFile(fn, File.GetLastWriteTime(fn));
}
}
}
catch (Exception)
{
try
{
// Don't show the error because this is just a non-critical background thread.
if (File.Exists(fileName)) app.UpdateFile(fileName, File.GetLastWriteTime(fileName));
}
catch (Exception)
{ }
}
}
public void UpdateFromModel(CodeModel.CodeModel model, FFDatabase db, FileStore store, DateTime fileModified, FFScanMode scanMode)
{
if (scanMode == FFScanMode.Deep)
{
_modified = fileModified;
}
else
{
_modified = Constants.ZeroDate;
}
UpdateVisibility();
InsertOrUpdate(db, store, model);
// Only extract functions for .f files or class files.
switch (_context)
{
case CodeModel.FileContext.Function:
case CodeModel.FileContext.ClientClass:
case CodeModel.FileContext.ServerClass:
case CodeModel.FileContext.NeutralClass:
// Get the list of functions defined in the file.
var modelFuncs = (from f in model.DefinitionProvider.GetGlobalFromFile <CodeModel.Definitions.FunctionDefinition>()
where f.Extern == false
select f).ToArray();
// Insert/update the functions that exist in the model.
foreach (var modelFunc in modelFuncs)
{
var func = _functions.FirstOrDefault(f => f.Name == modelFunc.Name);
if (func != null)
{
func.UpdateFromDefinition(modelFunc);
}
else
{
func = new FFFunction(_app, this, _class, modelFunc);
_functions.Add(func);
}
func.InsertOrUpdate(db);
}
// Purge functions that no longer exist in the model.
var removeFuncs = (from f in _functions where !modelFuncs.Any(m => m.Name == f.Name) select f).ToArray();
foreach (var removeFunc in removeFuncs)
{
removeFunc.Remove(db);
_functions.Remove(removeFunc);
}
break;
}
// Get all permanent extracts in the file
UpdatePermExList(db, model.File.FindDownward <CodeModel.Tokens.Statements.ExtractStatement>().Where(x => x.IsPermanent).ToArray());
if (scanMode == FFScanMode.Deep)
{
// Get all references in the file.
var refList = new List <Reference>();
foreach (var token in model.File.FindDownward(t => t.SourceDefinition != null &&
!string.IsNullOrEmpty(t.SourceDefinition.ExternalRefId) &&
t.File != null))
{
var localPos = token.File.CodeSource.GetFilePosition(token.Span.Start);
var def = token.SourceDefinition;
var refId = def.ExternalRefId;
if (!string.IsNullOrEmpty(refId))
{
refList.Add(new Reference
{
ExternalRefId = refId,
TrueFileName = string.Equals(localPos.FileName, model.FileName, StringComparison.OrdinalIgnoreCase) ? null : localPos.FileName,
Position = localPos.Position
});
}
}
foreach (var rf in model.PreprocessorReferences)
{
var def = rf.Definition;
var refId = def.ExternalRefId;
if (!string.IsNullOrEmpty(refId))
{
var filePos = rf.FilePosition;
if (filePos.PrimaryFile)
{
refList.Add(new Reference
{
ExternalRefId = refId,
TrueFileName = filePos.FileName,
Position = filePos.Position
});
}
}
}
UpdateRefList(db, refList);
}
}
private void UpdateIncludeDependencies(FFDatabase db, CodeModel.FileStore store, CodeModel.CodeModel model)
{
var modelIncludeList = model.PreprocessorModel.IncludeDependencies.ToArray();
var dbIncludes = new List <DbInclude>();
using (var cmd = db.CreateCommand("select rowid, include_file_name, include, localized_file from include_depends where file_id = @file_id"))
{
cmd.Parameters.AddWithValue("@file_id", _id);
using (var rdr = cmd.ExecuteReader())
{
while (rdr.Read())
{
dbIncludes.Add(new DbInclude
{
id = rdr.GetInt64(0),
fileName = rdr.GetString(1),
include = rdr.GetTinyIntBoolean(2),
localizedFile = rdr.GetTinyIntBoolean(3)
});
}
}
}
// Remove dependencies that are no longer there
var recordsToRemove = (from d in dbIncludes
where !modelIncludeList.Any(m => m.FileName.Equals(d.fileName, StringComparison.OrdinalIgnoreCase) &&
m.Include == d.include &&
m.LocalizedFile == d.localizedFile)
select d).ToArray();
if (recordsToRemove.Length > 0)
{
using (var cmd = db.CreateCommand("delete from include_depends where rowid = @rowid"))
{
foreach (var id in recordsToRemove)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@rowid", id);
cmd.ExecuteNonQuery();
}
}
}
// Add new dependencies
var recordsToAdd = (from m in modelIncludeList
where !dbIncludes.Any(d => d.fileName.Equals(m.FileName, StringComparison.OrdinalIgnoreCase) &&
d.include == m.Include &&
d.localizedFile == m.LocalizedFile)
select m).ToArray();
if (recordsToAdd.Length > 0)
{
using (var cmd = db.CreateCommand(@"
insert into include_depends (app_id, file_id, include_file_name, include, localized_file)
values (@app_id, @file_id, @include_file_name, @include, @localized_file)
" ))
{
foreach (var incl in recordsToAdd)
{
cmd.Parameters.Clear();
cmd.Parameters.AddWithValue("@app_id", _app.Id);
cmd.Parameters.AddWithValue("@file_id", _id);
cmd.Parameters.AddWithValue("@include_file_name", incl.FileName);
cmd.Parameters.AddWithValue("@include", incl.Include ? 1 : 0);
cmd.Parameters.AddWithValue("@localized_file", incl.LocalizedFile ? 1 : 0);
cmd.ExecuteNonQuery();
}
}
}
}
