/// <summary>
/// Creates an instance of a lexical analyzer based on a file extension.
/// </summary>
/// <param name="fileExtension">Extension of a file.</param>
/// <returns>Lexical analyzer object.</returns>
public static ILexicalAnalyzer GetLexicalAnalyzer(string fileExtension)
{
ILexicalAnalyzer analyzer = null;
switch (fileExtension)
{
case ".c":
analyzer = new CPPLexicalAnalyzer();
break;
case ".cpp":
analyzer = new CPPLexicalAnalyzer();
break;
case ".java":
analyzer = new JavaLexicalAnalyzer();
break;
case ".cs":
analyzer = new CSharpLexicalAnalyzer();
break;
case ".py":
analyzer = new PythonLexicalAnalyzer();
break;
}
return(analyzer);
}
/// <summary>
/// 设置词法分析器
/// <para>只有在分析线程完成分析工作且要赋的值不为null时才会更改此属性</para>
/// </summary>
/// <param name="lexicalAnalyzer"></param>
public void SetLexicalAnalyzer(ILexicalAnalyzer <TEnumTokenType> lexicalAnalyzer)
{
if (lexicalAnalyzer != null && this.m_SourceCodeWatchdog.NotDealtCount() == 0)
{
m_LexicalAnalyzer = lexicalAnalyzer;
}
}
public Parser(ILexicalAnalyzer scanner)
{
if (scanner == null)
throw new ArgumentNullException("scanner");
this.scanner = scanner;
}
public UnitExpressionParserTests()
{
var unitRegistry = new UnitRegistry();
this.lexicalAnalyzer = A.Fake <ILexicalAnalyzer>();
this.testee = new UnitExpressionParser(unitRegistry, this.lexicalAnalyzer);
}
public LexerTests()
{
var memStream = new MemoryStream(Encoding.UTF8.GetBytes(_data));
var reader = new StreamReader(memStream);
var source = new Source(reader);
_sys = new LexicalAnalyzer(source);
}
public Parser(ILexicalAnalyzer scanner)
{
if (scanner == null)
{
throw new ArgumentNullException("scanner");
}
this.scanner = scanner;
}
public FormulaParser(string formula)
{
if (string.IsNullOrEmpty(formula))
{
throw new ArgumentNullException(nameof(formula));
}
expressionAccessor = new ExpressionAccessor(formula);
lexicalAnalyzer = new LexicalAnalyzer(expressionAccessor);
}
/// <summary>
/// Removes all the unnecessary characters in files with the correct extensions.
/// </summary>
/// <param name="correctFiles">A collection containing file names with the correct extensions.</param>
/// <param name="clearedFilesPath">The path where the files with the correct extensions are located.</param>
/// <param name="taskFiles">A collection containing files of a given task.</param>
/// <param name="task">The task for which the files were loaded.</param>
/// <param name="author">The author of the correct files that are being processed.</param>
public void ProcessCorrectFiles(List <string> correctFiles, string clearedFilesPath, List <FileEntry> taskFiles, Model.Models.Task task, string author)
{
foreach (var cf in correctFiles)
{
string path = clearedFilesPath + Path.GetFileName(cf);
try
{
File.Copy(cf, path);
}
catch (Exception ex)
{
File.Copy(cf, path + "(1)");
}
string fileContent = File.ReadAllText(path);
string hashBeforePreprocessing = CalculateHash(fileContent);
long fileSize = new System.IO.FileInfo(path).Length;
int noOfLines = File.ReadLines(cf).Count();
string fileExtension = DetermineFileExtension(Path.GetExtension(Path.GetFileName(cf)));
int noOfEmptyLines = Regex.Matches(fileContent, "\n\n").Count
+ Regex.Matches(fileContent, "\r\r").Count
+ Regex.Matches(fileContent, "\r\n\r\n").Count;
noOfLineComments = 0;
noOfBlockComments = 0;
fileContent = RemoveComments(path, fileContent);
fileContent = RemoveUnnecessaryCharsFromFile(fileContent);
ILexicalAnalyzer lexAnalyzer = LexerFactory.GetLexicalAnalyzer(fileExtension);
string fileContentAfterLexer = lexAnalyzer.Tokenize(fileContent);
fileContent = PrepareInputForAnalysis(fileContent);
fileContentAfterLexer = PrepareInputForAnalysis(fileContentAfterLexer);
string hashAfterPreprocessing = CalculateHash(fileContent);
taskFiles.Add(new FileEntry()
{
FileName = Path.GetFileName(cf),
FileAuthor = author,
FileCheckSumBeforePreprocessing = hashBeforePreprocessing,
FileCheckSumAfterPreprocessing = hashAfterPreprocessing,
FileSize = fileSize,
FileNoOfLines = noOfLines,
FileNoOfEmptyLines = noOfEmptyLines,
FileNoOfLineComments = noOfLineComments,
FileNoOfBlockComments = noOfBlockComments,
FileContent = fileContent,
FileContentAfterLexAnalysis = fileContentAfterLexer,
FileExtension = fileExtension,
TaskId = task.Id
});
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitSystemDependencies"/> class.
/// </summary>
/// <param name="unitRegistry">The unit registry.</param>
/// <param name="lexicalAnalyzer">The lexical analyzer.</param>
/// <param name="expressionParser">The expression parser.</param>
/// <param name="quantityParser">The quantity parser.</param>
/// <param name="unitFactory">The unit factory.</param>
/// <param name="quantityOperations">The quantity operations.</param>
public UnitSystemDependencies(
UnitRegistry unitRegistry,
ILexicalAnalyzer lexicalAnalyzer,
IExpressionParser expressionParser,
IQuantityParser quantityParser,
IUnitFactory unitFactory,
IQuantityOperations quantityOperations)
{
this.UnitRegistry = unitRegistry;
this.LexicalAnalyzer = lexicalAnalyzer;
this.ExpressionParser = expressionParser;
this.QuantityParser = quantityParser;
this.UnitFactory = unitFactory;
this.QuantityOperations = quantityOperations;
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitSystemDependencies"/> class.
/// </summary>
/// <param name="unitRegistry">The unit registry.</param>
/// <param name="lexicalAnalyzer">The lexical analyzer.</param>
/// <param name="expressionParser">The expression parser.</param>
/// <param name="quantityParser">The quantity parser.</param>
/// <param name="unitFactory">The unit factory.</param>
/// <param name="quantityOperations">The quantity operations.</param>
public UnitSystemDependencies(
UnitRegistry unitRegistry,
ILexicalAnalyzer lexicalAnalyzer,
IExpressionParser expressionParser,
IQuantityParser quantityParser,
IUnitFactory unitFactory,
IQuantityOperations quantityOperations)
{
this.UnitRegistry = unitRegistry;
this.LexicalAnalyzer = lexicalAnalyzer;
this.ExpressionParser = expressionParser;
this.QuantityParser = quantityParser;
this.UnitFactory = unitFactory;
this.QuantityOperations = quantityOperations;
}
public Controller(IMainForm view)
{
this.view = view;
view.SourceCodeAnalyzeRequired += View_SourceCodeAnalyzeRequired;
view.GrammarAnalyzeRequired += View_GrammarAnalyzeRequired;
view.OpenSourceCodeFileClick += View_OpenSourceCodeFileClick;
view.SaveFileClick += View_SaveFileClick;
view.BuildRequired += View_BuildRequired;
view.SetColorizer(new Colorizer <Lexeme>(new LexemePainter())
{
SourceFilter = x => x.Is(LexemeFlags.Reserved | LexemeFlags.TypeDefinition | LexemeFlags.Const),
WordSelector = x => x.Body
});
fileManager = new FileManager();
_lexicalAnalyzer = new LexicalAnalyzer();
_syntaxAnalyzer = new PDASyntaxAnalyzer(view.SetPDAOutput);
_polizGenerator = new PolizGenerator(_lexicalAnalyzer);
}
private void View_SourceCodeAnalyzeRequired(string source)
{
view.EnableRunButton();
view.HideConsole();
_lexicalAnalyzer = new LexicalAnalyzer();
_syntaxAnalyzer = new PDASyntaxAnalyzer(view.SetPDAOutput);
_polizGenerator = new PolizGenerator(_lexicalAnalyzer);
var lexemes = _lexicalAnalyzer.Analyze(source);
view.HighlightSourceCode(lexemes);
view.DisplayConstants(_lexicalAnalyzer.Constants.Select(x => new { Code = x.ConstCode, Body = x.Body, Type = x.Type }));
view.DisplayIdentificators(_lexicalAnalyzer.Identificators.Select(x => new { Code = x.ConstCode, Body = x.Body, Type = x.Type }));
view.DisplayLexemes(lexemes.Select(x => new { Body = x.Body, Type = x.Flags, Line = x.Line, Code = x.Code, ConstCode = x.ConstCode }));
if (_lexicalAnalyzer.HasErrors)
{
ShowErrors(_lexicalAnalyzer.Errors.Select(x => $"Lexical error: {x}"));
view.DisableRunButton();
_polizGenerator.Clear();
}
else
{
view.EnableRunButton();
_syntaxAnalyzer.Analyze(lexemes);
if (_syntaxAnalyzer.HasErrors)
{
ShowErrors(_syntaxAnalyzer.Errors.Select(x => $"Syntax error: {x}"));
view.DisableRunButton();
_polizGenerator.Clear();
}
else
{
_polizGenerator.MakePoliz();
}
}
view.SetPoliz(_polizGenerator.Poliz);
}
/// <summary>
/// Initializes the unit system.
/// </summary>
/// <param name="unitSystemDependencyFactory">The unit system dependency factory.</param>
/// <param name="registerUnitAction">The register unit action.</param>
/// <returns>A <see cref="UnitSystemDependencies"/>.</returns>
public UnitSystemDependencies InitializeUnitSystem(
IUnitSystemDependencyFactory unitSystemDependencyFactory,
Action <IUnitRegistrar> registerUnitAction)
{
this.LockedAction(
() =>
{
if (!this.isInitialized)
{
unitSystemDependencyFactory = unitSystemDependencyFactory
?? new UnitSystemDependencyFactory(
new ExpressionToFlatRepresentationConverter());
this.unitRegistry = unitSystemDependencyFactory.CreateUnitRegistry();
registerUnitAction?.Invoke(this.unitRegistry);
this.expressionParser = unitSystemDependencyFactory.CreateParser(this.unitRegistry);
this.lexicalAnalyzer =
unitSystemDependencyFactory.CreateLexicalAnalyzer(TokenMatching.CompositeUnit);
this.unitFactory = unitSystemDependencyFactory.CreateUnitFactory(this.unitRegistry);
this.quantityParser = unitSystemDependencyFactory.CreateParser(
this.expressionParser,
this.unitFactory);
this.quantityOperations =
unitSystemDependencyFactory.CreateQuantityOperations(this.unitFactory);
this.Dependencies = new UnitSystemDependencies(
this.unitRegistry,
this.lexicalAnalyzer,
this.expressionParser,
this.quantityParser,
this.unitFactory,
this.quantityOperations);
this.isInitialized = true;
}
});
return(this.Dependencies);
}
public McCeibMetricsCreator(ILexicalAnalyzer <IMcCeibMetrics> lexicalAnalyzer)
{
_lexicalAnalyzer = lexicalAnalyzer;
}
public void Initialize()
{
_lexicalAnalyzer = new LexicalAnalyzer();
_transpiler = new Transpiler(_lexicalAnalyzer);
}
public HalstedMetricsCreator(ILexicalAnalyzer <IHalstedMetrics> lexicalAnalyzer)
{
_lexicalAnalyzer = lexicalAnalyzer;
}
/// <summary>
/// Initializes the unit system.
/// </summary>
/// <param name="unitSystemDependencyFactory">The unit system dependency factory.</param>
/// <param name="registerUnitAction">The register unit action.</param>
public UnitSystemDependencies InitializeUnitSystem(
IUnitSystemDependencyFactory unitSystemDependencyFactory,
Action<IUnitRegistrar> registerUnitAction)
{
this.LockedAction(
() =>
{
if (!this.isInitialized)
{
unitSystemDependencyFactory = unitSystemDependencyFactory
?? new UnitSystemDependencyFactory(
new ExpressionToFlatRepresentationConverter());
this.unitRegistry = unitSystemDependencyFactory.CreateUnitRegistry();
registerUnitAction?.Invoke(this.unitRegistry);
this.expressionParser = unitSystemDependencyFactory.CreateParser(this.unitRegistry);
this.lexicalAnalyzer =
unitSystemDependencyFactory.CreateLexicalAnalyzer(TokenMatching.CompositeUnit);
this.unitFactory = unitSystemDependencyFactory.CreateUnitFactory(this.unitRegistry);
this.quantityParser = unitSystemDependencyFactory.CreateParser(
this.expressionParser,
this.unitFactory);
this.quantityOperations =
unitSystemDependencyFactory.CreateQuantityOperations(this.unitFactory);
this.Dependencies = new UnitSystemDependencies(
this.unitRegistry,
this.lexicalAnalyzer,
this.expressionParser,
this.quantityParser,
this.unitFactory,
this.quantityOperations);
this.isInitialized = true;
}
});
return this.Dependencies;
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitExpressionParser" /> class.
/// </summary>
/// <param name="unitRegistry">The unit registry.</param>
/// <param name="lexicalAnalyzer">The lexical analyzer.</param>
public UnitExpressionParser(IUnitRegistry unitRegistry, ILexicalAnalyzer lexicalAnalyzer)
{
this.unitRegistry = unitRegistry;
this.lexicalAnalyzer = lexicalAnalyzer;
}
public PolizGenerator(ILexicalAnalyzer lexicalAnalyzer)
{
_lexicalAnalyzer = lexicalAnalyzer;
Poliz = new List <string>();
}
public UnitExpressionParserTests()
{
var unitRegistry = new UnitRegistry();
this.lexicalAnalyzer = A.Fake<ILexicalAnalyzer>();
this.testee = new UnitExpressionParser(unitRegistry, this.lexicalAnalyzer);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnitExpressionParser" /> class.
/// </summary>
/// <param name="unitRegistry">The unit registry.</param>
/// <param name="lexicalAnalyzer">The lexical analyzer.</param>
public UnitExpressionParser(IUnitRegistry unitRegistry, ILexicalAnalyzer lexicalAnalyzer)
{
this.unitRegistry = unitRegistry;
this.lexicalAnalyzer = lexicalAnalyzer;
}
public Transpiler(ILexicalAnalyzer lexicalAnalyzer)
{
_lexicalAnalyzer = lexicalAnalyzer;
}
