public void Init()
{
patternsConverter = new PatternConverter();
patternsRepository = new MemoryPatternsRepository();
sourceCodeRep = new MemoryCodeRepository(
"<?php \n" +
"test_call_0();\n" +
"test_call_1(a);\n" +
"test_call_2(a, e);\n" +
"test_call_3(c, d, a);\n" +
"test_call_4(c, d, a, e);\n" +
"\n" +
"$password = a;\n" +
"call_with_password_param(1, $password, 2);\n" +
"\n" +
"$password2 = \"1234\";\n" +
"if ($password2->Length > 0) { }\n" +
"test_call_5(1, $password2, 2);\n" +
"$concat = \"111\" .\n" +
" \"222222222\" . \n" +
" \"333\";",
"samples.php"
);
workflow = new Workflow(sourceCodeRep, patternsRepository)
{
Logger = new LoggerMessageCounter()
};
}
public void Init()
{
patternsConverter = new PatternConverter(
new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef)));
patternsRep = new MemoryPatternsRepository();
sourceCodeRep = new MemoryCodeRepository(
"<?php \n" +
"test_call_0();\n" +
"test_call_1(a);\n" +
"test_call_2(a, e);\n" +
"test_call_3(c, d, a);\n" +
"test_call_4(c, d, a, e);\n" +
"\n" +
"$password = a;\n" +
"call_with_password_param(1, $password, 2);\n" +
"\n" +
"$password2 = \"1234\";\n" +
"if ($password2->Length > 0) { }\n" +
"test_call_5(1, $password2, 2);"
);
workflow = new Workflow(sourceCodeRep, Language.Php, patternsRep)
{
Logger = new LoggerMessageCounter()
};
}
public static MatchingResultDto[] GetMatchings(string code, string pattern, LanguageFlags analyzedLanguages,
LanguageFlags?patternLanguages = null)
{
var sourceCodeRep = new MemoryCodeRepository(code);
var patternsRep = new MemoryPatternsRepository();
var workflow = new Workflow(sourceCodeRep, analyzedLanguages, patternsRep)
{
Logger = new LoggerMessageCounter()
};
var processor = new DslProcessor();
var patternNode = (PatternNode)processor.Deserialize(pattern, patternLanguages ?? LanguageExt.AllPatternLanguages);
var p = new Pattern
{
Data = patternNode,
DebugInfo = pattern
};
var patternsConverter = new PatternConverter(
new JsonUstNodeSerializer(typeof(UstNode), typeof(PatternVarDef)));
patternsRep.Add(patternsConverter.ConvertBack(new List <Pattern>()
{
p
}));
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults.ToDto(workflow.SourceCodeRepository)
.OrderBy(r => r.PatternKey)
.ToArray();
return(matchingResults);
}
public static MatchResultDto[] GetMatches(TextFile source, string pattern,
IEnumerable <Language> analyzedLanguages,
IEnumerable <Language> patternLanguages = null)
{
var sourceRep = new MemorySourceRepository(source.Data, source.FullName)
{
Languages = new HashSet <Language>(analyzedLanguages)
};
var patternsRep = new MemoryPatternsRepository();
var logger = new TestLogger();
var workflow = new Workflow(sourceRep, patternsRep)
{
Logger = logger
};
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new TextFile(pattern)
{
PatternKey = pattern
});
patternNode.Languages = new HashSet <Language>(patternLanguages ?? LanguageUtils.PatternLanguages);
patternNode.DebugInfo = pattern;
var patternsConverter = new PatternConverter();
patternsRep.Add(patternsConverter.ConvertBack(new List <PatternRoot> {
patternNode
}));
workflow.Process();
MatchResultDto[] matchResults = logger.Matches.ToDto()
.OrderBy(r => r.PatternKey)
.ToArray();
return(matchResults);
}
public static MatchResultDto[] GetMatches(string code, string pattern,
IEnumerable <Language> analyzedLanguages,
IEnumerable <Language> patternLanguages = null)
{
var sourceCodeRep = new MemoryCodeRepository(code)
{
Languages = new HashSet <Language>(analyzedLanguages)
};
var patternsRep = new MemoryPatternsRepository();
var workflow = new Workflow(sourceCodeRep, patternsRep)
{
Logger = new LoggerMessageCounter()
};
var processor = new DslProcessor();
PatternRoot patternNode = processor.Deserialize(new CodeFile(pattern)
{
IsPattern = true
});
patternNode.Languages = new HashSet <Language>(patternLanguages ?? LanguageUtils.PatternLanguages.Values);
patternNode.DebugInfo = pattern;
var patternsConverter = new PatternConverter();
patternsRep.Add(patternsConverter.ConvertBack(new List <PatternRoot>()
{
patternNode
}));
WorkflowResult workflowResult = workflow.Process();
MatchResultDto[] matchResults = workflowResult.MatchResults.ToDto()
.OrderBy(r => r.PatternKey)
.ToArray();
return(matchResults);
}
public void Init()
{
patternsConverter = new PatternConverter();
patternsRepository = new MemoryPatternsRepository();
sourceRep = new FileSourceRepository(Path.Combine(TestUtility.TestsDataPath, "common-matching.php"));
}
internal void UpdateMatchings()
{
sourceCodeLogger.Clear();
var sourceCodeRep = new MemoryCodeRepository(sourceCodeTextBox.Text);
IPatternsRepository patternRepository;
if (!string.IsNullOrEmpty(ServiceLocator.PatternViewModel.Value))
{
patternRepository = new DslPatternRepository(ServiceLocator.PatternViewModel.Value, ServiceLocator.PatternViewModel.Languages);
}
else
{
patternRepository = new MemoryPatternsRepository();
}
var workflow = new Workflow(sourceCodeRep, SelectedLanguage, patternRepository, stage: Stage);
workflow.IsIncludeIntermediateResult = true;
workflow.Logger = sourceCodeLogger;
WorkflowResult workflowResult = workflow.Process();
MatchingResultDto[] matchingResults = workflowResult.MatchingResults
.ToDto(workflow.SourceCodeRepository)
.ToArray();
if (IsDeveloperMode)
{
AntlrParseTree antlrParseTree = workflowResult.ParseTrees.FirstOrDefault() as AntlrParseTree;
if (antlrParseTree != null && antlrParseTree.SyntaxTree != null)
{
Antlr4.Runtime.Parser antlrParser = (workflow.ParserConverterSets[antlrParseTree.SourceLanguage].Parser as AntlrParser).Parser;
string tokensString = AntlrHelper.GetTokensString(antlrParseTree.Tokens, antlrParser.Vocabulary, onlyDefaultChannel: true);
string treeString = antlrParseTree.SyntaxTree.ToStringTreeIndented(antlrParser);
Tokens = tokensString;
ParseTree = treeString;
File.WriteAllText(Path.Combine(ServiceLocator.TempDirectory, "Tokens.txt"), Tokens);
File.WriteAllText(Path.Combine(ServiceLocator.TempDirectory, "Tree.txt"), ParseTree);
}
if (Stage >= Stage.Convert && workflowResult.Usts.FirstOrDefault() != null)
{
UstJson = jsonSerializer.Serialize(workflowResult.Usts.FirstOrDefault().Root);
File.WriteAllText(Path.Combine(ServiceLocator.TempDirectory, "UST.json"), UstJson);
}
}
MatchingResultText = "MATCHINGS";
if (matchingResults.Count() > 0)
{
MatchingResultText += " (" + matchingResults.Count() + ")";
}
if (sourceCodeLogger.ErrorCount == 0)
{
SourceCodeErrorsIsVisible = false;
SourceCodeErrorsText = "ERRORS";
}
else
{
SourceCodeErrorsIsVisible = true;
SourceCodeErrorsText = $"ERRORS ({sourceCodeLogger.ErrorCount})";
}
Dispatcher.UIThread.InvokeAsync(() =>
{
MatchingResults.Clear();
foreach (var matchingResult in matchingResults)
{
MatchingResults.Add(new MathingResultDtoWrapper(matchingResult));
}
this.RaisePropertyChanged(nameof(Tokens));
this.RaisePropertyChanged(nameof(ParseTree));
this.RaisePropertyChanged(nameof(UstJson));
this.RaisePropertyChanged(nameof(MatchingResultText));
this.RaisePropertyChanged(nameof(SourceCodeErrorsIsVisible));
this.RaisePropertyChanged(nameof(SourceCodeErrorsText));
});
}
public static IPatternsRepository CreatePatternsRepository(string patternsString,
IEnumerable <string> patternIds,
ILogger logger)
{
IPatternsRepository patternsRepository;
if (string.IsNullOrEmpty(patternsString) || patternsString == "default")
{
patternsRepository = new DefaultPatternRepository();
}
else if (patternsString.EqualsIgnoreCase("no"))
{
patternsRepository = DummyPatternsRepository.Instance;
}
else if (patternsString.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
{
patternsRepository = new JsonPatternsRepository(FileExt.ReadAllText(patternsString));
}
else
{
TextFile patternsFile;
if (patternsString.EndsWith(".pattern", StringComparison.OrdinalIgnoreCase))
{
patternsFile = new TextFile(FileExt.ReadAllText(patternsString))
{
PatternKey = patternsString,
Name = patternsString
};
}
else
{
patternsFile = new TextFile(patternsString);
}
var processor = new DslProcessor();
if (logger != null)
{
processor.Logger = logger;
}
PatternRoot patternRoot = processor.Deserialize(patternsFile);
var patternConverter = new PatternConverter();
if (logger != null)
{
patternConverter.Logger = logger;
}
List <PatternDto> dtos = patternConverter.ConvertBack(new[] { patternRoot });
var memoryPatternsRepository = new MemoryPatternsRepository();
memoryPatternsRepository.Add(dtos);
patternsRepository = memoryPatternsRepository;
}
if (logger != null)
{
patternsRepository.Logger = logger;
}
patternsRepository.Identifiers = patternIds as List <string> ?? patternIds?.ToList();
return(patternsRepository);
}
