public void Append(CodeSource source)
{
foreach (var seg in source._segments)
{
Append(seg.text, seg.fileName, seg.startPos, seg.endPos, seg.actualContent, seg.primaryFile, seg.disabled);
}
}
public CodeSourcePreprocessorReader(CodeSource src)
{
#if DEBUG
if (src == null)
{
throw new ArgumentNullException("src");
}
#endif
_src = src;
_segIndex = 0;
_segOffset = 0;
if (_src._segments.Count > 0)
{
_seg = _src._segments[_segIndex];
_pos = _seg.startPos;
_segLength = _seg.length;
}
else
{
_seg = null;
_pos = 0;
_segLength = 0;
}
}
public CodeModel CreatePreprocessedModel(ProbeAppSettings appSettings, string fileName, VsText.ITextSnapshot snapshot, bool visible, string reason)
{
CodeSource source;
IEnumerable <Preprocessor.IncludeDependency> includeDependencies = null;
if (visible)
{
source = new CodeSource();
source.Append(snapshot.GetText(), fileName, 0, snapshot.Length, true, true, false);
source.Flush();
}
else
{
var merger = new FileMerger();
merger.MergeFile(appSettings, fileName, snapshot.GetText(), false, true);
source = merger.MergedContent;
includeDependencies = (from f in merger.FileNames
select new Preprocessor.IncludeDependency(f, false, true, merger.GetFileContent(f))).ToArray();
}
var model = CreatePreprocessedModel(appSettings, source, fileName, visible, reason, includeDependencies);
model.Snapshot = snapshot;
return(model);
}
public PreprocessorModel(CodeSource source, DefinitionProvider defProv, string fileName, bool visible, IEnumerable <Preprocessor.IncludeDependency> includeDependencies)
{
#if DEBUG
if (source == null)
{
throw new ArgumentNullException("source");
}
if (defProv == null)
{
throw new ArgumentNullException("defProv");
}
#endif
_source = source;
_code = new CodeParser(source.Text);
_defProv = defProv;
_fileName = fileName;
FunctionFileScanning.FFUtil.FileNameIsClass(_fileName, out _className);
_fileContext = FileContextUtil.GetFileContextFromFileName(fileName);
_visible = visible;
if (includeDependencies != null)
{
_includeDependencies = includeDependencies.ToArray();
}
else
{
_includeDependencies = new Preprocessor.IncludeDependency[0];
}
Parse();
}
public CodeSource GetSource(ProbeAppSettings appSettings)
{
if (_source == null)
{
try
{
var merger = new FileMerger();
merger.MergeFile(appSettings, _fullPathName, null, false, false);
_source = merger.MergedContent;
var fileInfo = new FileInfo(_fullPathName);
_lastModifiedDate = fileInfo.LastWriteTime;
_lastCheck = DateTime.Now;
foreach (var mergeFileName in merger.FileNames)
{
var content = merger.GetFileContent(mergeFileName);
if (content == null)
{
throw new InvalidOperationException("Merger content is null.");
}
_preMergeContent[mergeFileName.ToLower()] = content;
}
}
catch (Exception ex)
{
Log.Error(ex, "Exception when attempting to read content of include file '{0}'.", _fullPathName);
_source = null;
}
}
return(_source);
}
private static CodeModel.CodeSource GetCodeSourceForActiveView(out string fileName)
{
ThreadHelper.ThrowIfNotOnUIThread();
var view = Shell.ActiveView;
if (view != null)
{
fileName = VsTextUtil.TryGetDocumentFileName(view.TextBuffer);
var content = view.TextBuffer.CurrentSnapshot.GetText();
try
{
var merger = new CodeModel.FileMerger();
merger.MergeFile(ProbeEnvironment.CurrentAppSettings, fileName, content, true, true);
return(merger.MergedContent);
}
catch (Exception ex)
{
Log.WriteEx(ex);
var codeSource = new CodeModel.CodeSource();
codeSource.Append(content, new CodeModel.CodeAttributes(fileName, 0, content.Length, true, true, false));
codeSource.Flush();
return(codeSource);
}
}
fileName = null;
return(null);
}
public static CodeModel CreateFullModelForPreprocessed(CodeSource source, ProbeAppSettings appSettings, FileStore store, PreprocessorModel prepModel)
{
var model = new CodeModel(appSettings, store);
var codeFile = new CodeFile(model);
model.Init(source, codeFile, prepModel.FileName, false, prepModel.DefinitionProvider);
return(model);
}
private void AppendIncludeFile(PreprocessorParams p, string fileName, bool searchSameDir)
{
// Load the include file
string[] parentFiles;
if (string.IsNullOrEmpty(p.fileName))
{
parentFiles = p.parentFiles;
if (parentFiles == null)
{
parentFiles = new string[0];
}
}
else
{
if (p.parentFiles != null)
{
parentFiles = p.parentFiles.Concat(new string[] { p.fileName }).ToArray();
}
else
{
parentFiles = new string[0];
}
}
var includeNode = _store.GetIncludeFile(_appSettings, p.fileName, fileName, searchSameDir, parentFiles);
if (includeNode == null)
{
return;
}
if (p.stopAtIncludeFile != null && includeNode.FullPathName.Equals(p.stopAtIncludeFile, StringComparison.OrdinalIgnoreCase))
{
p.result.IncludeFileReached = true;
return;
}
var rawSource = includeNode.GetSource(_appSettings);
if (rawSource == null)
{
return;
}
var reader = new CodeSource.CodeSourcePreprocessorReader(rawSource);
// Run the preprocessor on the include file.
var includeSource = new CodeSource();
var parms = new PreprocessorParams(reader, includeSource, includeNode.FullPathName, parentFiles, p.fileContext, p.contentType, p.stopAtIncludeFile);
p.result.Merge(Preprocess(parms));
p.writer.Append(includeSource);
foreach (var preMergeFileName in includeNode.PreMergeFileNames)
{
AddIncludeDependency(preMergeFileName, true, false, includeNode.GetPreMergeContent(preMergeFileName));
}
}
public CodeModel CreatePreprocessedModel(ProbeAppSettings appSettings, string fileName, VsText.ITextSnapshot snapshot, string reason)
{
var source = new CodeSource();
source.Append(snapshot.GetText(), fileName, 0, snapshot.Length, true, true, false);
source.Flush();
var model = CreatePreprocessedModel(appSettings, source, fileName, true, reason, null);
model.Snapshot = snapshot;
return(model);
}
private static void CreateStdLibModel(ProbeAppSettings appSettings)
{
var tempStore = new FileStore();
var includeFile = tempStore.GetIncludeFile(appSettings, null, "stdlib.i", false, new string[0]);
if (includeFile != null)
{
_stdLibModel = tempStore.CreatePreprocessedModel(appSettings, includeFile.GetSource(appSettings),
includeFile.FullPathName, false, "stdlib.i model", null);
}
else
{
var blankSource = new CodeSource();
blankSource.Flush();
_stdLibModel = tempStore.CreatePreprocessedModel(appSettings, blankSource, "stdlib.i", false,
"stdlib.i model (blank)", null);
}
_stdLibDefines = _stdLibModel.PreprocessorModel.Preprocessor.Defines.ToArray();
}
private void Init(CodeSource source, CodeFile file, string fileName, bool visible, DefinitionProvider defProvider)
{
#if DEBUG
if (defProvider == null)
{
throw new ArgumentNullException("defProvider");
}
#endif
this.RefreshTime = DateTime.Now;
_fileName = fileName;
if (!string.IsNullOrEmpty(_fileName))
{
_fileTitle = Path.GetFileNameWithoutExtension(_fileName);
}
_fileContext = FileContextUtil.GetFileContextFromFileName(_fileName);
if (FunctionFileScanning.FFUtil.FileNameIsFunction(fileName))
{
_modelType = ModelType.Function;
}
else if (FunctionFileScanning.FFUtil.FileNameIsClass(fileName, out _className))
{
_modelType = DkTools.CodeModel.ModelType.Class;
}
else
{
_modelType = DkTools.CodeModel.ModelType.Other;
}
_defProvider = defProvider;
_file = new CodeFile(this);
_file.Parse(source, _fileName, new string[0], visible);
this.RefreshTime = DateTime.Now;
}
public void Append(CodeSource source)
{
Append(source.Text, CodeAttributes.Empty);
}
private void OnFileChangeSuspected()
{
_source = null;
_codeFile = null;
}
public Definition[] GetIncludeParentDefinitions(ProbeAppSettings appSettings, string includePathName)
{
Definition[] cachedDefs;
if (_includeParentDefs.TryGetValue(includePathName.ToLower(), out cachedDefs))
{
return(cachedDefs);
}
Log.Debug("Getting include file parent definitions: {0}", includePathName);
IEnumerable <string> parentFileNames;
using (var searcher = ProbeToolsPackage.Instance.FunctionFileScanner.CurrentApp.CreateSearcher())
{
parentFileNames = searcher.GetIncludeParentFiles(includePathName, 3); // TODO: make limit configurable
}
Definition[] commonDefines = null;
if (!parentFileNames.Any())
{
Log.Debug("This file is not included by any other file.");
commonDefines = new Definition[0];
_includeParentDefs[includePathName.ToLower()] = commonDefines;
return(commonDefines);
}
foreach (var parentPathName in parentFileNames)
{
Log.Debug("Preprocessing include parent: {0}", parentPathName);
var merger = new FileMerger();
merger.MergeFile(appSettings, parentPathName, null, false, true);
var source = merger.MergedContent;
var reader = new CodeSource.CodeSourcePreprocessorReader(source);
var prepSource = new CodeSource();
var fileContext = FileContextUtil.GetFileContextFromFileName(parentPathName);
var prep = new Preprocessor(appSettings, this);
var prepResult = prep.Preprocess(reader, prepSource, parentPathName, new string[0], fileContext, includePathName);
if (!prepResult.IncludeFileReached)
{
Log.Warning("Include file not reached when preprocessing parent.\r\nInclude File: {0}\r\nParent File: {1}",
includePathName, parentPathName);
continue;
}
var defs = prep.ActiveDefineDefinitions;
if (!defs.Any())
{
// No defines will be common
Log.Debug("No definitions found in include parent file: {0}", parentPathName);
commonDefines = new Definition[0];
break;
}
if (commonDefines == null)
{
commonDefines = defs.ToArray();
Log.Debug("{1} definition(s) found in include parent file: {0}", parentPathName, commonDefines.Length);
}
else
{
// Create array of defines common to all
commonDefines = (from c in commonDefines where defs.Any(d => d.Name == c.Name) select c).ToArray();
Log.Debug("{1} definition(s) found in include parent file: {0}", parentPathName, commonDefines.Length);
if (commonDefines.Length == 0)
{
break;
}
}
}
if (commonDefines == null)
{
commonDefines = new Definition[0];
}
Log.Debug("Using {0} definition(s) from include parent files.", commonDefines.Length);
_includeParentDefs[includePathName.ToLower()] = commonDefines;
return(commonDefines);
}
public CodeModel CreatePreprocessedModel(ProbeAppSettings appSettings, CodeSource source, string fileName,
bool visible, string reason, IEnumerable <Preprocessor.IncludeDependency> includeDependencies)
{
#if DEBUG
Log.Debug("Creating preprocessed model. Reason: {0}", reason);
var startTime = DateTime.Now;
#endif
var reader = new CodeSource.CodeSourcePreprocessorReader(source);
var prepSource = new CodeSource();
var defProvider = new DefinitionProvider(appSettings, fileName);
var fileContext = FileContextUtil.GetFileContextFromFileName(fileName);
var prep = new Preprocessor(appSettings, this);
if (includeDependencies != null)
{
prep.AddIncludeDependencies(includeDependencies);
}
prep.Preprocess(reader, prepSource, fileName, new string[0], fileContext, stdlibDefines: _stdLibDefines);
prep.AddDefinitionsToProvider(defProvider);
if (fileContext == FileContext.Include && !string.IsNullOrEmpty(fileName))
{
var includeParentDefs = GetIncludeParentDefinitions(appSettings, fileName);
defProvider.AddGlobalFromFile(includeParentDefs);
}
#if DEBUG
var midTime1 = DateTime.Now;
#endif
var prepModel = new PreprocessorModel(prepSource, defProvider, fileName, visible, prep.IncludeDependencies)
{
Preprocessor = prep
};
#if DEBUG
var midTime2 = DateTime.Now;
#endif
CodeModel modelToReturn;
if (visible)
{
modelToReturn = CodeModel.CreateVisibleModelForPreprocessed(source, appSettings, this, prepModel);
modelToReturn.PreprocessorModel = prepModel;
modelToReturn.DisabledSections = prepSource.GenerateDisabledSections().ToArray();
}
else
{
modelToReturn = CodeModel.CreateFullModelForPreprocessed(prepSource, appSettings, this, prepModel);
modelToReturn.PreprocessorModel = prepModel;
}
modelToReturn.PreprocessorReferences = prep.References;
#if DEBUG
var endTime = DateTime.Now;
var elapsedTime = endTime.Subtract(startTime).TotalMilliseconds;
var prepTime = midTime1.Subtract(startTime).TotalMilliseconds;
var modelTime = midTime2.Subtract(midTime1).TotalMilliseconds;
var visTime = endTime.Subtract(midTime2).TotalMilliseconds;
Log.Debug("Created model in {0} msecs ({1} preprocessor, {2} model, {3} visible)", elapsedTime, prepTime, modelTime, visTime);
#endif
return(modelToReturn);
}
public void MergeFile(ProbeAppSettings appSettings, string fileName, string content, bool showMergeComments, bool fileIsPrimary)
{
if (appSettings == null)
{
throw new ArgumentNullException(nameof(appSettings));
}
_appSettings = appSettings;
// Locate all needed copies of files
_primaryFileName = fileName;
_origFileName = "";
_localFileNames.Clear();
_showMergeComments = showMergeComments;
var rawFileName = fileName;
if (Path.IsPathRooted(fileName))
{
fileName = UnrootFileName(fileName);
}
FindFiles(fileName);
if (string.IsNullOrEmpty(_origFileName))
{
throw new FileMergeException(string.Format("Could not find base file for '{0}'.", rawFileName));
}
if (content == null)
{
_origContent = File.ReadAllText(_origFileName);
}
else
{
_origContent = content;
}
// Perform localization
CreateLineDataFromOrigFile(_origContent);
foreach (string localFileName in _localFileNames)
{
try
{
MergeFile(localFileName);
}
catch (Exception ex)
{
Log.Error(ex, "Error when merging local file '{0}' into '{1}'.", localFileName, fileName);
}
}
// Generate the final source.
_mergedContent = new CodeSource();
int lineIndex = 0;
foreach (var line in _lines)
{
var primary = fileIsPrimary && _primaryFileName.Equals(line.fileName, StringComparison.OrdinalIgnoreCase);
var endPos = line.pos + line.text.Length;
_mergedContent.Append(line.text, new CodeAttributes(line.fileName, line.pos, endPos, true, primary, false));
if (!line.text.EndsWith("\n") && lineIndex + 1 < _lines.Count)
{
// Does not end with crlf. Need to insert between the lines.
_mergedContent.Append("\r\n", new CodeAttributes(line.fileName, endPos, endPos, false, primary, false));
}
lineIndex++;
}
_mergedContent.Flush();
}
