//----< setup and execute the parser >-----------------
static void parse(string file)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.WriteLine(" Can't open {0}", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build(true);
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.WriteLine(" {0}", ex.Message);
}
semi.close();
}
//------< to find types defiend, functions and Complexity and size of functions >-----
public static void doAnalysis(string[] files)
{
string filename = null;
foreach (object file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
filename = file.ToString();
while (semi.getSemi())
parser.parse(semi, filename);
// filename store with types and function to identify which types belongs to which file.
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
typetable= RepositoryForOutput.storageForOutput_;
}
}
//------< to find types defiend, functions and Complexity and size of functions >-----
public static void doAnalysis(string[] files)
{
string filename = null;
foreach (object file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
filename = file.ToString();
while (semi.getSemi())
{
parser.parse(semi, filename);
}
// filename store with types and function to identify which types belongs to which file.
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
typetable = RepositoryForOutput.storageForOutput_;
}
}
//----------<parse1 starts here, it identifies all the types>-----------------
public void doAnalysis(string[] files)
{
foreach (object file in files)
{
string filename = Convert.ToString(file);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi, filename);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List<Elem> table = rep.locations; //storing the repository data into a List
semi.close();
}
}
// ------------< to find Relationship between types defiend >--------------
public static void doRelationAnalysis(string[] files)
{
string filename = null;
foreach (object file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzerRelation builder = new BuildCodeAnalyzerRelation(semi);
Parser parser = builder.build();
try
{
filename = file.ToString();
while (semi.getSemi())
parser.parse(semi, filename);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
}
}
static public void doAnalysis(string[] files)
{
int skipCount = 0;
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
Repository rep = Repository.getInstance();
List<Elem> fileSetInfo = new List<Elem>(); // store type and name of file set, use for relationship analysis
foreach (string file in files)
{
if(Display.showFiles)
Display.displayString("");
Display.displayFiles(act, "Processing file: " + file);
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
foreach (Elem e in rep.locations)
{
e.filename = file;
}
List<Elem> table = rep.locations;
if (table.Count == 0)
{
++skipCount;
continue;
}
fileSetInfo.AddRange(rep.locations); // push all elements in current file into inquiry table
semi.close();
rep.LocationsTable[file] = table; // Obtained all the types and names of the file set, locationTable is actually a inquiry table
rep.locations = new List<Elem>();
}
doAnalysis_Again(fileSetInfo, files);
displaySkipped(skipCount);
//displayAnalysis(rep);
//analysisSummary(rep);
}
// ------------< to find Relationship between types defiend >--------------
public static void doRelationAnalysis(string[] files)
{
string filename = null;
foreach (object file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzerRelation builder = new BuildCodeAnalyzerRelation(semi);
Parser parser = builder.build();
try
{
filename = file.ToString();
while (semi.getSemi())
{
parser.parse(semi, filename);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
}
}
//----------<parse1 starts here, it identifies all the types>-----------------
public void doAnalysis(string[] files)
{
foreach (object file in files)
{
string filename = Convert.ToString(file);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi, filename);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations; //storing the repository data into a List
semi.close();
}
}
// function that parse all the files and build a inquiry table
static void doAnalysis(string[] files, bool relation, bool xml)
{
List<Elem> fileSetInfo = new List<Elem>(); // store type and name of file set, use for relationship analysis
List<Elem> summaryTAB = new List<Elem>(); // store size and complexity, use for display summary of the whole file set
foreach (object file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi); // creat a repository
Parser parser = builder.build(); // creat a parser object and five rule object, attach the rules to parser
try
{
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
fileSetInfo.AddRange(rep.locations); // push all elements in current file into inquiry table
semi.close();
}
secondAnalysis(files, fileSetInfo, summaryTAB, relation, xml);
}
//----< Test Stub >--------------------------------------------------
#if (TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
ShowCommandLine(args);
/* If the package is run as stand alone application
* then add the default values for the member variables
*/
try
{
List <string> files = TestParser.ProcessCommandline(args);
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
Console.Write("\n\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
foreach (Elem e in table)
{
Console.Write("\n {0,10}, {1,25}, {2,5}, {3,5}", e.type, e.name, e.begin, e.end);
}
Console.WriteLine();
semi.close();
Console.ReadLine();
}
}
catch
{
Console.WriteLine("Error in parsing");
}
}
protected CSsemi.CSemiExp GetSemiExpressionFromFile(object file)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return(null);
}
return(semi);
}
static public void doAnalysis(string[] files)
{
int skipCount = 0;
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
Repository rep = Repository.getInstance();
foreach (string file in files)
{
if (Display.showFiles)
{
Display.displayString("");
}
Display.displayFiles(act, "Processing file: " + file);
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
List <Elem> table = rep.locations;
if (table.Count == 0)
{
++skipCount;
continue;
}
semi.close();
rep.LocationsTable[file] = table;
rep.locations = new List <Elem>();
}
displaySkipped(skipCount);
displayAnalysis(rep);
analysisSummary(rep);
}
//----< Test Stub for Parser >--------------------------------------------------
#if (TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
ShowCommandLine(args);
List <string> files = TestParser.ProcessCommandline(args);
foreach (object file in files)
{
string filename = Convert.ToString(file);
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi, filename);
}
Console.Write("\n\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
foreach (Elem e in table)
{
if (e.type == "function")
{
Console.Write("\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}", e.type, e.name, e.begin, e.end, e.functionComplexity);
}
}
Console.WriteLine();
Console.Write("\n\n That's all folks!\n\n");
semi.close();
}
}
static public void doAnalysis(string[] files,bool relationship) {
BuildCodeAnalyzer builder;
BuildCodeAnalyzer_relation builder_relation;
Parser parser;
Parser parser_;
for(int i=0;i<2;i++) {
foreach (object file in files) {
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
CSsemi.CSemiExp semi_relation = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string)) {
Console.Write("\n Can't open {0}\n\n", file);
return;
}
if (!semi_relation.open(file as string)) {
Console.Write("\n Can't open {0}\n\n", file);
return;
}
if (i == 0) {
builder = new BuildCodeAnalyzer(semi);
parser = builder.build();
Repository rep1 = Repository.getInstance();
rep1.setfilename(Path.GetFileName(file.ToString()));
try {
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
}
else {
builder_relation = new BuildCodeAnalyzer_relation(semi_relation);
parser_ = builder_relation.build_relation();
Repository rep1 = Repository.getInstance();
rep1.setfilename(Path.GetFileName(file.ToString()));
try {
while (semi_relation.getSemi())
parser_.parse(semi_relation);
}
catch (Exception ex) {
Console.Write("\n\n {0}\n", ex.Message);
}
}
semi.close(); }
if (!relationship)
return;
}
}
/// <summary>
/// This is the method where we create the code anlayser object.
/// There will be only one code analyser object for all the files.
/// It uses the parser module to find the relationship analysis.
/// Once the results are generated, it will be stored in the centralised
/// repo. We use this centralised repo from other module to know
/// the type and dependency analysis.
/// </summary>
/// <param name="serverName"></param>
public void analyze(string serverName)
{
Console.Write("\n CODE ANALYZER");
Console.Write("\n ======================\n");
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
try
{
foreach (object file in files)
{
Console.Write("\n\n Processing file {0}\n", file as string);
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
CodeAnalysis.Parser parser = builder.build();
Repository repo = Repository.getInstance();
repo.CurrentFileName = file.ToString();
Elem elem = getDefaultElemData(file.ToString(), serverName);
repo.locations.Add(elem);
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
}
}
catch (Exception)
{
Console.WriteLine("Error in the data. Exception thrown, pls check the input");
}
}
public List <Elem> typesBetweenFiles = new List <Elem>(); //list to store info between files
public void doAnalysis(string[] files)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
//**processes it for every file one after another*********
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
CodeAnalysis.BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi); //parses every semi expression
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
typesBetweenFiles = rep.locations;
foreach (Elem e in table)
{
Console.Write("\n {0,10}, {1,25}, {2,5}, {3,5}", e.type, e.name, e.begin, e.end);
}
Console.WriteLine();
Console.Write("\n\n That's all folks!\n\n");
semi.close();
}
}
//----< Test Stub >--------------------------------------------------
#if (TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
ShowCommandLine(args);
List <string> files = TestParser.ProcessCommandline(args);
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
Console.Write("\n\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
Console.Write("\n\n That's all folks!\n\n");
semi.close();
}
}
/*
* Method to parse through list of user input files and parse
* for all user defined types
*/
public static void parseUserDefinedTypes(List <string> files)
{
if (files.Count == 0)
{
return;
}
foreach (String file in files)
{
Console.Write("Parsing for all user defined types");
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file.ToString());
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
CodeAnalysis.Parser parser = builder.build();
//test against the detect class rule
try
{
//use the existing parser to test rule
while (semi.getSemi())
{
int index = isClassExpression(semi);
if (index != -1)
{
CSsemi.CSemiExp local = new CSsemi.CSemiExp();
// local semiExp with tokens for type and name
local.displayNewLines = false;
local.Add(semi[index]).Add(semi[index + 1]);
userDefinedSet.Add(semi[index + 1]);
}
}
}
catch (Exception ex) {
Console.Write("\n\n {0}", ex.Message);
}
}
// return userDefinedSet;
}
static void doAnalysis(string[] files)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi);
Console.Write("\n\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List<Elem> table = rep.locations;
foreach (Elem e in table)
{
Console.Write("\n {0,10}, {1,25}, {2,5}, {3,5} , {4,5}", e.type, e.name, e.begin, e.end, e.end - e.begin + 1);
}
Console.WriteLine();
Console.Write("\n\n That's all folks!\n\n");
semi.close();
}
}
//read the list of files, one by one and calls BuildCodeAnalyzer and parser functions
public void analyze(string serverName)
{
Console.Write("\n CODE ANALYZER");
Console.Write("\n ======================\n");
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
foreach (object file in files)
{
Console.Write("\n\n Processing file {0}\n", file as string);
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
CodeAnalysis.Parser parser = builder.build();
Repository repo = Repository.getInstance();
Elem elem = getDefaultElemData(file.ToString(), serverName);
repo.analyzedata.Add(elem);
try
{
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
}
}
//*****second parse************//
public void reldoAnalysis(string[] files)
{
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
Repository rep_inst = Repository.getInstance();
Repository.Copy_buffer = typesBetweenFiles;
BuildCodeAnalyzer_types builder_ty = new BuildCodeAnalyzer_types(semi);
Parser parser = builder_ty.build();
// sends every semi again for relationship analysis
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
//stores all the updation to the type and relationship list back to the repository
Repository_types rep = Repository_types.getInstance();
List <relationelem> table = rep.classrelations;
rel_BetweenFiles = (rep.classrelations);
}
}
/// <summary>
/// This method is used for the second round of analysis.
/// Since there are multiple servers, we need to merge the partial type
/// table of each of the server to find the depenendency across various
/// servers. Once the first parse is done, the client sends the type table
/// of all other servers. At this point, we will merge the existing type
/// table with other server type table and then use this updated table
/// to find the final dependeny results.
/// </summary>
public void analyzeSecondParse()
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
try
{
foreach (object file in files)
{
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzerForRelationshipTypes builderreln = new BuildCodeAnalyzerForRelationshipTypes(semi);
CodeAnalysis.Parser parser = builderreln.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
}
}
catch (Exception ex)
{
Console.Write("\n\n Error in the input data. Exception {0}. Please check the input data\n", ex.Message);
}
}
static void doAnalysis(string[] files, bool relation_flag, bool xml_flag)
{
List<Elem> TABLE = new List<Elem>();
foreach (object file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
TABLE.AddRange(rep.locations); // Build a TABLE to store all the elements, provided to be searched for relationshipAnalysis class
semi.close();
}
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
// parse all files and store the elements into table for each file
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi);
Console.Write("\n\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List<Elem> table = rep.locations;
// display basic information for elements including size and complexity
Console.Write("\n type name begin end size complexity");
foreach (Elem e in table)
{
if (e.type == "function")
{
ComplexityAnalysis ca = new ComplexityAnalysis();
e.complexity = ca.ComplexityAnalyze(e, file);
}
Console.Write("\n {0,9}, {1,20}, {2,8}, {3,8}, {4,8}, {5,8}", e.type, e.name, e.begin, e.end, e.end - e.begin + 1, e.complexity);
}
//display the relationships between classes
if (relation_flag == true)
{
foreach (Elem e in table)
{
e.AggregationFlag = false;
e.CompositionFlag = false;
e.UsingFlag = false;
if (e.type == "class" || e.type == "struct" || e.type == "interface")
{
Console.Write("\n\n {0} {1}", e.type, e.name);
Console.Write("------------------------------------------------------\n");
RelationshipAnalysis ra = new RelationshipAnalysis();
ra.RelationshipAnalyzer(e, file, TABLE);
foreach (Elem ele in TABLE)
{
ele.AggregationFlag = false;
ele.CompositionFlag = false;
ele.UsingFlag = false;
}
}
}
}
Console.WriteLine();
//display xml files for each file
if (xml_flag == true)
{
XML x = new XML();
x.XmlBuilder(table, (string)file);
}
}
Console.Write("\n");
DisplaySummary(TABLE);
}
/// <summary>
/// Starts the part 2 of analysis to find out the package and relationship dependency
/// </summary>
public void analyzePartII()
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
foreach (object file in files)
{
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzerRelationships builderreln = new BuildCodeAnalyzerRelationships(semi);
CodeAnalysis.Parser parser = builderreln.build();
try
{
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
}
}
static public void doAnalysis_Again(List<Elem> fileSetInfo, string[] files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
Repository rep = Repository.getInstance();
foreach (string file in files)
{
if (Display.showFiles)
Display.displayString("");
Display.displayFiles(act, "Processing file: " + file);
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
foreach (Elem e in rep.locations)
{
e.filename = file;
}
List<Elem> table = rep.locations;
if (table.Count == 0)
{
continue;
}
List<string> filename = new List<string>();
filename.Add("");
fileDependencyTable.Add(file, filename);
foreach (Elem e in table) // analysis each element's dependency if it is a class or struct or interface
{
if (e.type == "class" || e.type == "struct" || e.type == "interface")
dependencyAnalyzer.dependencyAnalysis(e, file, fileSetInfo);
foreach (Elem ee in fileSetInfo)
{
if (e.dependency.Contains(ee.name) && !fileDependencyTable[file].Contains(ee.filename) && ee.filename != file)
{
fileDependencyTable[file].Add(ee.filename);
}
}
}
semi.close();
rep.LocationsTable[file] = table; // obtained all the types and names of the file set, locationTable is actually a inquiry table
rep.locations = new List<Elem>();
}
displayAnalysis(rep);
analysisSummary(rep);
}
//read the list of files, one by one and calls BuildCodeAnalyzer and parser functions
public void analyze()
{
Console.Write("\n CODE ANALYZER");
Console.Write("\n ======================\n");
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
foreach (object file in files)
{
Console.Write("\n\n Processing file {0}\n", file as string);
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
CodeAnalysis.Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
if (relationshipflag)
{
semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzerRelationships builderreln = new BuildCodeAnalyzerRelationships(semi);
parser = builderreln.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
}
semi.close();
}
}
public void doAnalysis(string[] files)
{
// Parser p = new Parser();
//p.parseFiles(files);
//NEW DESIGN
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
CSsemi.CSemiExp semi2 = new CSsemi.CSemiExp();
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
foreach (object file in files)
{
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
// Console.Write("\n Type and Function Analysis");
// Console.Write("\n ----------------------------\n");
// Console.WriteLine("processing file{0}", file as string);
try
{
if (semi.getSemi())
{
semi2 = semi;
parser.parse(semi);
}
while (semi.getSemi())
{
parser.parse(semi);
}
//Console.Write("\n\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
Parser parser2 = builder.build2(rep, semi2);
foreach (object file in files)
{
// CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi2.displayNewLines = false;
if (!semi2.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
try
{
do
{
parser2.parse(semi2);
} while (semi2.getSemi());
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
//Repository rep = Repository.getInstance();
semi2.close();
}
}
//----< Test Stub >--------------------------------------------------
#if(TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
List<string> files = TestParser.ProcessCommandline(args);
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
while (semi.getSemi())
parser.parse(semi);
//Console.Write("\n\n locations table contains:");
Repository rep = Repository.getInstance();
List<Elem> table = rep.locations;
foreach (Elem e in table)
{
// Console.Write("\n {0,10}, {1,25}, {2,5}, {3,5}", e.type, e.name, e.begin, e.end);
}
//Console.WriteLine();
// Console.Write("\n\n That's all folks!\n\n");
semi.close();
}
}
// function that parse each file, detect class relationship, function size and complexity
static void secondAnalysis(string[] files, List<Elem> fileSetInfo, List<Elem> summaryTAB, bool relation, bool xml)
{
foreach (object file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List<Elem> table = rep.locations;
ComplexityAnalyzer comxAna = new ComplexityAnalyzer();
foreach (Elem e in table) // analysis each element's complexity if it is a function
{
if (e.type == "function")
e.complexity = comxAna.complexityAnalysis(e, file, fileSetInfo);
}
summaryTAB.AddRange(table);
RelationshipAnalyzer relshAna = new RelationshipAnalyzer();
foreach (Elem e in table) // analysis each element's relationship if it is a class or struct or interface
{
if (e.type == "class" || e.type == "struct" || e.type == "interface")
relshAna.relationshipanalysis(e, file, fileSetInfo);
}
display(table, file, relation, xml);
semi.close();
}// all the files in file set had been parsed
summary(summaryTAB, relation);
}
public int ComplexityAnalyze(Elem e, Object file)
{
CSsemi.CSemiExp local = new CSsemi.CSemiExp();
local.open(file as string);
int complexity = 1;
while(local.lineCount<e.begin)
{
local.getSemi();
}
while(local.lineCount <= e.end)
{
local.getSemi();
if (local.Contains("if") != -1)
complexity++;
if (local.Contains("else") != -1)
complexity++;
if (local.Contains("for") != -1)
complexity++;
if (local.Contains("foreach") != -1)
complexity++;
if (local.Contains("while") != -1)
complexity++;
if (local.Contains("try") != -1)
complexity++;
if (local.Contains("catch") != -1)
complexity++;
if (local.Contains("case") != -1)
complexity++;
}
return complexity;
}
static void Main(string[] args)
{
List <string> CSharpFiles = Ingest.GenerateFileStructure(args);
List <string> contentList = new List <string>();
foreach (string file in CSharpFiles)
{
Console.Write("\n Processing file {0}\n", System.IO.Path.GetFileName(file));
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
Console.Write("\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"category", "name", "bLine", "eLine", "bScop", "eScop", "size", "cmplx"
);
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"--------", "----", "-----", "-----", "-----", "-----", "----", "-----"
);
List <string> functionList = new List <string>();
foreach (Elem e in table)
{
if (e.type == "class" || e.type == "struct" || e.type == "Comment")
{
Console.Write("\n");
}
Console.Write("\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
e.type, e.name, e.beginLine, e.endLine, e.beginScopeCount, e.endScopeCount + 1,
e.endLine - e.beginLine + 1, e.endScopeCount - e.beginScopeCount + 1
);
if (e.type == "function")
{
contentList = PostProcessor.getContentBetweenLines(file, e.beginLine, e.endLine);
functionList.Add(e.name);
}
if (e.type == "class" || e.type == "namespace")
{
PostProcessor.addObjectToFile(e.name, file);
}
HTML_Builder.buildFileStructure(file, e.type, e.name, e.beginLine, e.endLine, contentList);
}
PostProcessor.addFileToFileList(functionList, file);
Console.Write("\n");
semi.close();
}
PostProcessor.buildDependencies(CSharpFiles);
HTML_Builder.generateFileList(CSharpFiles);
foreach (string file in CSharpFiles)
{
HTML_Builder.buildPageContent(file.Substring(file.LastIndexOf("\\") + 1), CSharpFiles);
}
Console.Write("\n\n");
}
//read the list of files, one by one and calls BuildCodeAnalyzer and parser functions
public void analyze()
{
Console.Write("\n CODE ANALYZER");
Console.Write("\n ======================\n");
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
foreach (object file in files)
{
Console.Write("\n\n Processing file {0}\n", file as string);
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
CodeAnalysis.Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
if (relationshipflag)
{
semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzerRelationships builderreln = new BuildCodeAnalyzerRelationships(semi);
parser = builderreln.build();
try
{
while (semi.getSemi())
parser.parse(semi);
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
}
semi.close();
}
}
//----< Test Stub >--------------------------------------------------
#if(TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
//Repository rep_global;
//List<Elem> table_global;
ShowCommandLine(args);
List<string> files = TestParser.ProcessCommandline(args);
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------\n");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi);
Console.Write("\n\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List<Elem> table = rep.locations;
////////
ComplexityAnalyzer comxAna = new ComplexityAnalyzer();
foreach (Elem e in table)
{
if (e.type == "function")
e.complexity = comxAna.complexityAnalysis(e, file);
}
RelationshipAnalyzer relshAna = new RelationshipAnalyzer();
foreach (Elem e in table)
{
if (e.type == "class" || e.type == "struct" || e.type == "interface")
relshAna.relationshipanalysis(e, file);
}
/////////
foreach (Elem e in table)
{
Console.Write("\n {0,10}, {1,25}, {2,5}, {3,5}, {4,50}", e.type, e.name, e.end-e.begin+1, e.complexity, e.relationship);
}
Console.WriteLine();
Console.Write("\n\n That's all folks!\n\n");
semi.close();
}
}
/* This method is used to call the relationship and complexity analysis
* for each file in the input set
*/
public void analyze()
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
/* These are the supported file formats in this tool. If input file is not in this format,
* then analysis will not be done*/
string[] supportedFileFormatList = { ".cs", ".c", ".cpp", ".java", ".txt", ".bat" };
foreach (object file in files)
{
string fileExtension = Path.GetExtension(file.ToString());
bool supportedFileFormat = false;
foreach (string currentFileExtension in supportedFileFormatList)
{
if (fileExtension == currentFileExtension)
{
supportedFileFormat = true;
}
}
if (!supportedFileFormat)
{
Console.WriteLine("\nThe file {0} is of unsupported format", file.ToString());
continue;
}
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
CodeAnalysis.Parser parser = builder.build();
Repository repo = Repository.getInstance();
Elem elem = getDefaultElemData(file.ToString());
repo.locations.Add(elem);
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
semi.close();
//Only when the user specifies the /R option, we do relationship analysis
if (findRelationship)
{
semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file);
return;
}
BuildCodeAnalyzerForRelationshipTypes builderreln = new BuildCodeAnalyzerForRelationshipTypes(semi);
parser = builderreln.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
}
semi.close();
}
}
//----< Test Stub >--------------------------------------------------
#if (TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
ShowCommandLine(args);
//THIS RETURNS A LIST OF FILES THAT THE USER PASSED IN
List <string> files = TestParser.ProcessCommandline(args);
for (int i = 0; i < files.Count; i++)
{
Console.Write(files[i] + "\n");
}
//sh - preprocess all user input files to get all user defined types
UserType.parseUserDefinedTypes(files);
HashSet <string> definedSet = UserType.getUserDefinedSet();
Console.Write("Parser size of definedset" + definedSet.Count.ToString());
foreach (string file in files)
{
Console.Write("\n Processing file {0}\n", System.IO.Path.GetFileName(file));
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
Console.Write("\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
//all data is stored in table object
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}, {8,10}, {9, 10}, {10,6}",
"category", "name", "bLine", "eLine", "bScop", "eScop", "size", "cmplx", "coupling", "cohesion", "M-Index"
);
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}, {8,10}, {9,10}, {10,6}",
"--------", "----", "-----", "-----", "-----", "-----", "----", "-----", "--------", "--------", "-------"
);
foreach (Elem e in table)
{
if (e.type == "class" || e.type == "struct")
{
Console.Write("\n");
//get the maintainibility index
e.mIndex = getMaintainibilityIndex(e);
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}, {8,10}, {9,10}, {10,6}",
e.type, e.name, e.beginLine, e.endLine, e.beginScopeCount, e.endScopeCount + 1,
e.endLine - e.beginLine + 1, e.endScopeCount - e.beginScopeCount + 1, e.coupling, e.cohesion, e.mIndex
);
}
else
{
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}, {8,10}, {9,10}",
e.type, e.name, e.beginLine, e.endLine, e.beginScopeCount, e.endScopeCount + 1,
e.endLine - e.beginLine + 1, e.endScopeCount - e.beginScopeCount + 1, e.coupling, e.cohesion
);
}
}
Console.Write("\n\n");
semi.close();
}
Console.Write("\n\n");
}
public void RelationshipAnalyzer(Elem e, Object file, List<Elem> TABLE)
{
CSsemi.CSemiExp local = new CSsemi.CSemiExp();
local.open(file as string);
while (local.lineCount < e.begin)
{
local.getSemi();
}
while (local.lineCount < e.end)
{
InheritanceAnalyze(local, TABLE);
AggregationAnalyze(local, TABLE);
CompositionAnalyze(local, TABLE);
UsingAnalyze(local, TABLE, e);
local.getSemi();
}
}
//----< Test Stub >--------------------------------------------------
#if(TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
ShowCommandLine(args);
List<string> files = TestParser.ProcessCommandline(args);
foreach (string file in files)
{
Console.Write("\n Processing file {0}\n", System.IO.Path.GetFileName(file));
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------");
BuildCodeAnalyzer builder = new BuildCodeAnalyzer(semi);
Parser parser = builder.build();
try
{
while (semi.getSemi())
parser.parse(semi);
Console.Write("\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List<Elem> table = rep.locations;
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"category", "name", "bLine", "eLine", "bScop", "eScop", "size", "cmplx"
);
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"--------", "----", "-----", "-----", "-----", "-----", "----", "-----"
);
foreach (Elem e in table)
{
if (e.type == "class" || e.type == "struct")
Console.Write("\n");
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
e.type, e.name, e.beginLine, e.endLine, e.beginScopeCount, e.endScopeCount+1,
e.endLine-e.beginLine+1, e.endScopeCount-e.beginScopeCount+1
);
}
Console.Write("\n");
semi.close();
}
Console.Write("\n\n");
}
public int complexityAnalysis(Elem e, object file, List<Elem> fileSetInfo)
{
int count = 0;
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.open(file as string);
do
{
semi.getSemi();
} while (semi.lineCount < e.begin); // ignore all the semi before function begin
while (semi.lineCount <= e.end)
{
if (semi.Contains("if") != -1)
count++;
if (semi.Contains("else") != -1)
count++;
if (semi.Contains("for") != -1)
count++;
if (semi.Contains("foreach") != -1)
count++;
if (semi.Contains("while") != -1 && semi[semi.count - 1] != ";")
count++;
if (semi.Contains("do") != -1)
count++;
if (semi.Contains("case") != -1)
count++;
if (semi.Contains("try") != -1)
count++;
if (semi.Contains("catch") != -1)
count++;
if (specialCB(semi)) // special curly brace
count++;
semi.getSemi();
}
return count;
}
//----< analyzer execution start here! >-----------------
static int Main(string[] args)
{
List <string> files = processCommandline(args);
FileStream outputFileStream = null;
StreamWriter streamWriter = null;
if (files == null)
{
return(0);
}
if (optOutputToFile)
{
try
{
outputFileStream = new FileStream(optOutputToFileFilepath, FileMode.Create);
}
catch
{
Console.WriteLine("error: can create output file {0}.", optOutputToFileFilepath);
}
streamWriter = new StreamWriter(outputFileStream);
Console.SetOut(streamWriter);
}
Console.WriteLine();
Console.WriteLine("===============================================================================");
Console.WriteLine(" Code Maintainability Analyzer");
Console.WriteLine("===============================================================================");
Parser parser;
BuildCodeAnalyzer builder = null;
foreach (string file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.WriteLine(" Can't open {0}", args[0]);
return(-1);
}
builder = new BuildCodeAnalyzer(semi);
parser = builder.build(true);
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.WriteLine(" {0}", ex.Message);
}
semi.close();
}
foreach (string file in files)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write(" Can't open {0}", args[0]);
return(-1);
}
Console.WriteLine();
Console.WriteLine("-------------------------------------------------------------------------------");
Console.WriteLine(" Type and Function Analysis for {0}", System.IO.Path.GetFileName(file));
Console.WriteLine("-------------------------------------------------------------------------------");
builder = new BuildCodeAnalyzer(semi);
parser = builder.build(false);
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
}
catch (Exception ex)
{
Console.WriteLine(" {0}", ex.Message);
}
semi.close();
showOutput();
}
showSummary(files.Count);
showRelationships();
if (optOutputToFile)
{
streamWriter.Close();
}
return(0);
}
public void relationshipanalysis(Elem e, object file, List<Elem> fileSetInfo)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.open(file as string);
do
{
semi.getSemi();
} while (semi.lineCount < (e.begin-1)); // ignore semi before type define
while (semi.lineCount <= e.end)
{ // detect four kinds of relationship
inheritance(semi, e);
aggregation(semi, e, fileSetInfo);
composition(semi, e, fileSetInfo);
usingRelationship(semi, e, fileSetInfo);
semi.getSemi();
}
return;
}
public void findDefinedTypes(string file)
{
CodeAnalysis.Parser p = new CodeAnalysis.Parser();
enterScopeRule esr = new enterScopeRule();
displayEnterScope des = new displayEnterScope();
esr.add(des);
p.add(esr);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
if (!semi.open(file))
{
Console.Write("\n\n can't open file {0} for analysis\n", file);
}
while (semi.getSemi())
p.parse(semi);
}
//----< Test Stub >--------------------------------------------------
#if (TEST_PARSER)
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
ShowCommandLine(args);
Parser parser;
List <string> files = TestParser.ProcessCommandline(args);
BuildCodeAnalyzer builder = null;
foreach (string file in files)
{
Console.Write("\n Processing file {0}\n", System.IO.Path.GetFileName(file));
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------");
builder = new BuildCodeAnalyzer(semi);
parser = builder.build(true);
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
Console.Write("\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"category", "name", "bLine", "eLine", "bScop", "eScop", "size", "cmplx"
);
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"--------", "----", "-----", "-----", "-----", "-----", "----", "-----"
);
foreach (Elem e in table)
{
if (e.type == "class" || e.type == "struct")
{
Console.Write("\n");
}
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
e.type, e.name, e.beginLine, e.endLine, e.beginScopeCount, e.endScopeCount + 1,
e.endLine - e.beginLine + 1, e.endScopeCount - e.beginScopeCount + 1
);
}
Console.Write("\n");
semi.close();
}
foreach (string file in files)
{
Console.Write("\n Processing file {0}\n", System.IO.Path.GetFileName(file));
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n Type and Function Analysis");
Console.Write("\n ----------------------------");
builder = new BuildCodeAnalyzer(semi);
parser = builder.build(false);
try
{
while (semi.getSemi())
{
parser.parse(semi);
}
Console.Write("\n locations table contains:");
}
catch (Exception ex)
{
Console.Write("\n\n {0}\n", ex.Message);
}
Repository rep = Repository.getInstance();
List <Elem> table = rep.locations;
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"category", "name", "bLine", "eLine", "bScop", "eScop", "size", "cmplx"
);
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
"--------", "----", "-----", "-----", "-----", "-----", "----", "-----"
);
foreach (Elem e in table)
{
if (e.type == "class" || e.type == "struct")
{
Console.Write("\n");
}
Console.Write(
"\n {0,10}, {1,25}, {2,5}, {3,5}, {4,5}, {5,5}, {6,5}, {7,5}",
e.type, e.name, e.beginLine, e.endLine, e.beginScopeCount, e.endScopeCount + 1,
e.endLine - e.beginLine + 1, e.endScopeCount - e.beginScopeCount + 1
);
if (e.type == "class" || e.type == "struct")
{
CClassInfo classInfo = rep.parsedData.getClassInfo(e.name);
Console.WriteLine("Coupling: {0}", CCalculateMetrics.calculateCoupling(classInfo));
Console.WriteLine("Cohesion: {0}", CCalculateMetrics.calculateCohesion(classInfo));
}
}
Console.Write("\n");
semi.close();
}
Console.Write("\n\n");
}
static void Main(string[] args)
{
Console.Write("\n Demonstrating Parser");
Console.Write("\n ======================\n");
ArrayList files = TestParser.ProcessCommandline(args);
if (files.Count == 0)
{
Console.Write("\n couldn't retrieve any files to process\n\n");
return;
}
foreach (object file in files)
{
Console.Write("\n Processing file {0}\n", file as string);
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", args[0]);
return;
}
Console.Write("\n First - Type Analysis");
Console.Write("\n -----------------------\n");
BuildTypeAnal TAbuilder = new BuildTypeAnal();
Parser parser = TAbuilder.build();
while (semi.getSemi())
parser.parse(semi);
Console.Write("\n\n That's all the types folks!\n\n");
semi.close();
Console.Write("\n Now - Scope Analysis");
Console.Write("\n ----------------------");
BuildScopeAnal SAbuilder = new BuildScopeAnal();
parser = SAbuilder.build();
if (!semi.open(file as string))
{
Console.Write("\n Can't open {0}\n\n", file as string);
return;
}
while (semi.getSemi())
parser.parse(semi);
Console.Write("\n\n That's all the scopes folks!\n\n");
}
}
///////////////////////////////////////////////////////////////////////////////
//Locate does the job of locating the namespaces,functions and Class ranges. //
//It returns Table containing inforamtion about the Type,Name Begin Line and //
//Ending Lines of the above mentioned ranges. //
/////////////////////////////////////////////////////////////////////////////
public List<CodeAnalysis.Elem> Locate(FileInfo file)
{
CSsemi.CSemiExp semi = new CSsemi.CSemiExp();
semi.displayNewLines = false;
if (!semi.open(file.FullName as string))
{
return null;
}
CodeAnalysis.BuildCodeAnalyzer builder = new CodeAnalysis.BuildCodeAnalyzer(semi);
CodeAnalysis.Parser par = builder.build();
while (semi.getSemi())
par.parse(semi);
CodeAnalysis.Repository Rep = CodeAnalysis.Repository.getInstance();
//Store the Begin,End locations alone with Name and Type Information
List<CodeAnalysis.Elem> table = Rep.locations;
semi.close();
return Rep.locations;
}