/// <summary>
/// Interpreta un programa o un archivo
/// </summary>
private ProgramModel ParseProgram(string strFileName)
{
SolutionVisualStudioModel objSolution = new SolutionVisualStudioModel(strFileName);
ProgramModel objProgram = new ProgramModel(strFileName);
// Carga la solución
objSolution.Load();
// Interpreta los proyectos
foreach (ProjectVisualStudioModel objProject in objSolution.Projects)
{
foreach (FileVisualStudioModel objFile in objProject.Files)
{
if (!System.IO.File.Exists(objFile.FullFileName))
{
objProgram.Errors.Add("No se encuentra el archivo " + objFile.FullFileName);
}
else
{
CompilationUnitModel objUnit = ParseFile(objFile.FullFileName);
if (objUnit != null)
{
objProgram.CompilationUnits.Add(objUnit);
}
}
}
}
// Devuelve el programa interpretado
return(objProgram);
}
/// <summary>
/// Interpreta un texto
/// </summary>
internal CompilationUnitModel ParseText(string strText)
{
CompilationUnitModel objUnit = new CompilationUnitModel("PlainText");
// Interpreta el texto
ParseText(objUnit, strText);
// Devuelve la unidad de compilación
return(objUnit);
}
/// <summary>
/// Procesa los elementos de documentación
/// </summary>
private void AddNameSpacesToGroup(NameSpaceGroupModelCollection groups, CompilationUnitModel compilationUnit)
{
foreach (NameSpaceModel nameSpace in compilationUnit.SearchNameSpaces())
{
if (nameSpace != null)
{
groups.Add(nameSpace);
}
}
}
/// <summary>
/// Interpreta la unidad de compilación
/// </summary>
private void ParseNodes(CompilationUnitModel objUnit, SyntaxNode objRoot)
{
if (objRoot.Kind() == SyntaxKind.CompilationUnit)
{
ParseChilds(objRoot, objUnit.Root);
}
else
{
objUnit.Root.Error = "No se encuentra el nodo de unidad de compilación en el árbol sintáctico";
}
}
/// <summary>
/// Interpreta un texto
/// </summary>
private void ParseText(CompilationUnitModel objUnit, string strText)
{
CSharpCompilation objCompilation;
// Crea el modelo de compilación
objCompilation = CSharpCompilation.Create("ParserText").AddSyntaxTrees(CSharpSyntaxTree.ParseText(strText));
// Obtiene el árbol semántico
objTreeSemantic = objCompilation.GetSemanticModel(objCompilation.SyntaxTrees[0], true);
// Interpreta los nodos
ParseNodes(objUnit, objTreeSemantic.SyntaxTree.GetRoot());
}
/// <summary>
/// Interpreta un archivo
/// </summary>
protected override CompilationUnitModel ParseFile(String strFileName)
{
CompilationUnitModel objUnit = null;
// Interpreta el archivo
if (strFileName.EndsWith(".vb", StringComparison.CurrentCultureIgnoreCase))
{
objUnit = new Parser.VisualBasicParser().ParseFile(strFileName);
}
// Devuelve el archivo interpretado
return(objUnit);
}
/// <summary>
/// Interpreta un archivo
/// </summary>
protected override CompilationUnitModel ParseFile(String strFileName)
{
CompilationUnitModel objCompilationUnit = null;
// Interpreta el archivo
if (strFileName.EndsWith(".cs", StringComparison.CurrentCultureIgnoreCase))
{
objCompilationUnit = new Parser.CSharpParser().ParseFile(strFileName);
}
// Devuelve la unidad de compilación
return(objCompilationUnit);
}
/// <summary>
/// Interpreta un texto
/// </summary>
internal override CompilationUnitModel ParseText(string fileName, string text)
{
CompilationUnitModel unit = new CompilationUnitModel(fileName);
CSharpCompilation compilation;
// Crea el modelo de compilación
compilation = CSharpCompilation.Create("ParserText").AddSyntaxTrees(CSharpSyntaxTree.ParseText(text));
// Obtiene el árbol semántico
treeSemantic = compilation.GetSemanticModel(compilation.SyntaxTrees[0], true);
// Interpreta los nodos
ParseNodes(unit, treeSemantic.SyntaxTree.GetRoot());
// Devuelve la unidad de compilación
return(unit);
}
/// <summary>
/// Interpreta un texto
/// </summary>
protected override CompilationUnitModel ParseText(string strFileName, string strText)
{
CompilationUnitModel objUnit = new CompilationUnitModel(strFileName);
VisualBasicCompilation objCompilation;
// Crea el modelo de compilación
objCompilation = VisualBasicCompilation.Create("ParserText").AddSyntaxTrees(VisualBasicSyntaxTree.ParseText(strText));
// Obtiene el árbol semántico
objTreeSemantic = objCompilation.GetSemanticModel(objCompilation.SyntaxTrees[0], true);
// Interpreta los nodos
ParseNodes(objUnit, objTreeSemantic.SyntaxTree.GetRoot());
// Devuelve la unidad de compilación
return(objUnit);
}
/// <summary>
/// Añade las estructuras que no tienen un espacio de nombres
/// </summary>
private void AddStructsNoNameSpace(NameSpaceGroupModelCollection groups, CompilationUnitModel compilationUnit)
{
LanguageStructModelCollection structsDoc = compilationUnit.SearchNoNameSpaces();
if (structsDoc != null && structsDoc.Count > 0)
{
NameSpaceGroupModel group = GetGroupNoNameSpace(groups);
// Añade las estructuras
foreach (LanguageStructModel structDoc in structsDoc)
{
group.NameSpace.Items.Add(structDoc);
}
}
}
/// <summary>
/// Interpreta un archivo
/// </summary>
public CompilationUnitModel ParseFile(string strFileName)
{
CompilationUnitModel objUnit = new CompilationUnitModel(strFileName);
// Interpreta el archivo
if (!System.IO.File.Exists(strFileName))
{
objUnit.Root.Error = "No se encuentra el archivo " + strFileName;
}
else
{
objUnit = ParseText(strFileName, LibHelper.Files.HelperFiles.LoadTextFile(strFileName));
}
// Devuelve la unidad de compilación
return(objUnit);
}
/// <summary>
/// Interpreta un archivo
/// </summary>
internal CompilationUnitModel ParseFile(string strFileName)
{
CompilationUnitModel objUnit = new CompilationUnitModel(strFileName);
// Interpreta el archivo
if (!System.IO.File.Exists(strFileName))
{
objUnit.Root.Error = "No se encuentra el archivo " + strFileName;
}
else
{
try
{ ParseText(objUnit, LibHelper.Files.HelperFiles.LoadTextFile(strFileName)); }
catch (Exception objException)
{ objUnit.Root.Error = "Error al interpretar " + strFileName + ". " + objException.Message; }
}
// Devuelve la unidad de compilación
return(objUnit);
}
/// <summary>
/// Interpreta una solución
/// </summary>
private SolutionModel ParseSolution(string fileName)
{
SolutionVisualStudioModel solutionVisual = new SolutionVisualStudioModel(fileName);
SolutionModel solution = new SolutionModel(fileName);
// Carga la solución
solutionVisual.Load();
// Interpreta los proyectos
foreach (ProjectVisualStudioModel project in solutionVisual.Projects)
{
if (project.Files.Count > 0) // ... los proyectos sin archivos se corresponden a las carpetas de solución
{
ProgramModel program = new ProgramModel(project.FullFileNameSource);
// Interpreta los archivos del proyecto
foreach (FileVisualStudioModel file in project.Files)
{
if (!System.IO.File.Exists(file.FullFileName))
{
program.Errors.Add($"No se encuentra el archivo {file.FullFileName}");
}
else if (!file.FullFileName.EndsWith(".vb", StringComparison.CurrentCultureIgnoreCase) ||
file.FullFileName.EndsWith(".cs", StringComparison.CurrentCultureIgnoreCase))
{
CompilationUnitModel unit = ParseFile(file.FullFileName);
if (unit != null)
{
program.CompilationUnits.Add(unit);
}
}
}
// Añade el proyecto a la solución
solution.Programs.Add(program);
}
}
// Devuelve el programa interpretado
return(solution);
}
public LanguageStructModel(StructType typeId, LanguageStructModel parent, CompilationUnitModel compilationUnit = null)
{
Type = typeId;
Parent = parent;
CompilationUnit = compilationUnit;
}
public LanguageStructModel(StructType intIDType, LanguageStructModel objParent, CompilationUnitModel objCompilationUnit = null)
{
IDType = intIDType;
Parent = objParent;
CompilationUnit = objCompilationUnit;
}
/// <summary>
/// Añade las estructuras que no tienen un espacio de nombres
/// </summary>
private void AddStructsNoNameSpace(NameSpaceGroupModelCollection objColGroups, CompilationUnitModel objCompilationUnit)
{
LanguageStructModelCollection objColStructs = objCompilationUnit.SearchNoNameSpaces();
if (objColStructs != null && objColStructs.Count > 0)
{
NameSpaceGroupModel objGroup = GetGroupNoNameSpace(objColGroups);
// Añade las estructuras
foreach (LanguageStructModel objStruct in objColStructs)
{
objGroup.NameSpace.Items.Add(objStruct);
}
}
}
/// <summary>
/// Procesa los elementos de documentación
/// </summary>
private void AddNameSpacesToGroup(NameSpaceGroupModelCollection objColGroups, CompilationUnitModel objCompilationUnit)
{
List <NameSpaceModel> objColNameSpaces = objCompilationUnit.SearchNameSpaces();
// Añade los espacios de nombres al documento
foreach (NameSpaceModel objNameSpace in objColNameSpaces)
{
if (objNameSpace != null)
{
objColGroups.Add(objNameSpace);
}
}
}
