// $ANTLR start synpred3_Test
private void synpred3_Test_fragment()
{
EnterRule_synpred3_Test_fragment();
EnterRule("synpred3_Test_fragment", 8);
var retval = new CstNode("synpred3_Test_fragment");
try
{
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Test\\Test.g:21:23: ( '+' multiplication )
DebugEnterAlt(1);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Test\\Test.g:21:23: '+' multiplication
{
DebugLocation(21, 23);
Match(input, 14, Follow._14_in_synpred3_Test107); if (state.failed)
{
return;
}
DebugLocation(21, 27);
PushFollow(Follow._multiplication_in_synpred3_Test109);
multiplication();
PopFollow();
if (state.failed)
{
return;
}
}
}
finally
{
TraceOut("synpred3_Test_fragment", 8);
LeaveRule("synpred3_Test_fragment", 8);
LeaveRule_synpred3_Test_fragment();
}
}
public void ParseJavaText()
{
const string originalCode = @"class Klass {}";
var gen = CstGenerators.JavaUsingAntlr3;
/*** Code <=> CST ***/
var cst = gen.GenerateTreeFromCodeText(originalCode);
Assert.That(cst.Code, Is.EqualTo(originalCode));
// GenerateCodeFromTree() invokes Code
Assert.That(gen.GenerateCodeFromTree(cst), Is.EqualTo(originalCode));
/*** CST <=> XML ***/
var xml = cst.ToXml();
Assert.That(CstNode.FromXml(xml).Code, Is.EqualTo(originalCode));
// GenerateXmlFromTree() invokes ToXml()
Assert.That(
gen.GenerateXmlFromTree(cst).ToString(),
Is.EqualTo(xml.ToString()));
// GenerateTreeFromXml() invokes CstNode.FromXml()
Assert.That(
gen.GenerateTreeFromXml(xml).Code,
Is.EqualTo(originalCode));
/*** Code <=> XML (via CST) ***/
// GenerateXmlFromCodeText() invokes GenerateTreeFromCodeText() and ToXml()
Assert.That(
gen.GenerateXmlFromCodeText(originalCode).ToString(),
Is.EqualTo(xml.ToString()));
// GenerateCodeFromXml() invokes CstNode.FromXml() and Code
Assert.That(
gen.GenerateCodeFromXml(xml),
Is.EqualTo(originalCode));
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
var pName = node.SafeParent().FirstChild.Name;
if (pName == "If")
{
return(true);
}
if (pName == "While")
{
return(true);
}
if (pName == "Do")
{
return(true);
}
if (node.SafeParent().Name == "commaList" &&
node.SafeParent().SafeParent().Name == "forCondition" &&
!node.NextsFromSelf().Any())
{
return(true);
}
if (node.SafeParent().Name == "commaList" &&
node.SafeParent().SafeParent().Name == "simpleStatement" &&
node.SafeParent().SafeParent().FirstChild.Name == "Echo" &&
node.Prev == null)
{
return(true);
}
return(false);
}
private static void ConvertIndiciesToRange(
CstNode node, string code, int inclusiveStart, int exclusiveEnd, CodeRange range)
{
var newRange = CodeRange.ConvertFromIndicies(code, inclusiveStart, exclusiveEnd);
var newInclusiveStart = char.IsWhiteSpace(code[inclusiveStart - 1])
? inclusiveStart - 1 : inclusiveStart;
var newExclusiveEnd = char.IsWhiteSpace(code[exclusiveEnd])
? exclusiveEnd + 1 : exclusiveEnd;
var elem = CodeRange.ConvertFromIndiciesSkippingWhitespaces(
code, ref newInclusiveStart, ref newExclusiveEnd)
.FindInnermostNode(node);
Assert.That(CodeRange.Locate(elem), Is.EqualTo(newRange));
newRange.ConvertToIndicies(code, out newInclusiveStart, out newExclusiveEnd);
Assert.That(newRange, Is.EqualTo(range));
Assert.That(newInclusiveStart, Is.EqualTo(inclusiveStart));
Assert.That(newExclusiveEnd, Is.EqualTo(exclusiveEnd));
var scode = new StructuredCode(code);
Assert.That(
CodeRange.ConvertFromIndicies(scode, inclusiveStart, exclusiveEnd),
Is.EqualTo(range));
newRange.ConvertToIndicies(scode, out newInclusiveStart, out newExclusiveEnd);
Assert.That(newInclusiveStart, Is.EqualTo(inclusiveStart));
Assert.That(newExclusiveEnd, Is.EqualTo(exclusiveEnd));
}
/// <summary>
/// Update SurroundingRange, TargetRange, and Node properties then return the last index of the code processed.
/// </summary>
/// <param name="structuredCode">The structured code processed</param>
/// <param name="cst">The concrete syntax tree</param>
/// <param name="fragments"></param>
/// <returns>The updated last index of the code processed</returns>
public static List<SeedNode> ConstructAcceptingFragments(StructuredCode structuredCode, CstNode cst, IList<SelectedFragment> fragments) {
var seedNodes = CreateSeedNodes(structuredCode, cst, fragments);
var uppermostSeedAcceptedNodes = seedNodes
.Select(node => node.Node.AncestorWithSingleChild())
.ToImmutableHashSet();
// We can select multiple nodes in corresponding to a fragment selected by a user
// and it means that we have multiple choices for selecting node names to filter nodes
// This code tries to select good node names to not filter nodes wanted by a user
var selectedNodeNames = LearningExperimentUtil.FindGoodNodeNames(uppermostSeedAcceptedNodes)
.ToImmutableHashSet();
foreach (var seedNode in seedNodes) {
// Update the node in corresponding to the selected node names keeping the code range of the node
seedNode.Node = seedNode.Node.DescendantsOfSingleAndSelf()
.First(e => selectedNodeNames.Contains(e.Name));
var rootNode = seedNode.SurroundingRange.FindInnermostNode(cst);
var node = seedNode.Node;
var path = node.Name;
while ((node = node.Parent) != rootNode) {
path = path + "<" + node.Name + node.RuleId;
}
seedNode.Path = path;
}
return seedNodes;
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
return(((node.TokenText == "*" || node.TokenText == "/") &&
node.Parent.Name == "multiplicative_expression") ||
((node.TokenText == "+" || node.TokenText == "-") &&
node.Parent.Name == "additive_expression"));
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
var siblings = node.Siblings().ToList();
var parent = node.Parent;
if (parent.SafeName() == "stat" && siblings[0].TokenText == "if")
{
return(node.TokenText != "true");
}
if (parent.SafeName() == "stat" && siblings[0].TokenText == "while")
{
return(node.TokenText != "true");
}
if (parent.SafeName() == "stat" && siblings[0].TokenText == "repeat")
{
return(node.TokenText != "true");
}
var ppp = node.SafeParent().SafeParent().SafeParent();
var pppp = ppp.SafeParent();
if (pppp.SafeName() == "functioncall" && ppp.Prev != null &&
ppp.Prev.TokenText == "print")
{
return(node.TokenText != "true");
}
return(false);
}
private void PrintNotDistinguishedElement(
CstNode e, BigInteger vector, EncodingResult result, LearningExperiment oracle)
{
if (--_printCount >= 0)
{
Console.WriteLine("==========================================");
Console.WriteLine(e.Parent.Name + ", " + e.Name + ", " + e.Code);
Console.WriteLine(Experiment.GetGoodAncestorNode(e).Code);
Console.WriteLine(
result.Vector2Node[vector].Parent.Name + ", "
+ result.Vector2Node[vector].Name + ", "
+ result.Vector2Node[vector].Code);
Console.WriteLine(Experiment.GetGoodAncestorNode(result.Vector2Node[vector]).Code);
Console.WriteLine("------------------------------------------");
if (Experiment.GetGoodAncestorNode(e).Code.Contains("Contract.Requires") &&
Experiment.GetGoodAncestorNode(result.Vector2Node[vector])
.Code.Contains("Contract.Requires"))
{
oracle.IsAcceptedUsingOracle(e);
oracle.IsAcceptedUsingOracle(result.Vector2Node[vector]);
}
foreach (var featureString in GetFeatureStringsByVector(vector))
{
Console.WriteLine(Experiment.Beautify(featureString));
}
}
}
public ElementListViewItem(CodeRange range, CstNode element)
: base(new[] { element.Name.LocalName, element.Value })
{
Range = range;
Element = element;
ToolTipText = element.ToString();
}
public static HashSet <string> GetUnionKeys(
this ICollection <CstNode> nodes, ICollection <SelectedFragment> fragments,
FeatureExtractor extractor)
{
var commonKeys = new HashSet <string>();
var usedRangeCount = 0;
if (nodes.Count > 0)
{
var root = nodes.First().AncestorsAndSelf().Last();
foreach (var node in nodes)
{
IEnumerable <CstNode> surroundingNodes;
CstNode outermostNode = null;
var fragment = fragments
.FirstOrDefault(f => node.AncestorWithSingleChild() == f.Node);
if (fragment != null)
{
surroundingNodes = fragment.SurroundingRange.FindOverlappedNodes(root);
outermostNode = fragment.SurroundingRange.FindInnermostNode(root);
usedRangeCount++;
}
else
{
surroundingNodes = node.DescendantsAndSelf();
}
var keys = node.GetSurroundingPaths(
surroundingNodes.ToHashSet(), extractor, outermostNode);
commonKeys.UnionWith(keys);
}
}
Console.WriteLine("#Used Ranges: " + usedRangeCount);
return(commonKeys);
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
var parentName = node.Parent.SafeName();
if (parentName == "ifStatement")
{
return(true);
}
if (parentName == "whileStatement")
{
return(true);
}
if (parentName == "doWhileStatement")
{
return(true);
}
if (parentName == "forStatement" &&
node.Prev == node.Parent.Children().First(e2 => e2.TokenText == ";"))
{
return(true);
}
var p = node.SafeParent().SafeParent();
if (p.SafeName() == "callExpression" && p.FirstChild.TokenText == "console.log" &&
p.Child("arguments").Child("assignmentExpression") == node)
{
return(true);
}
return(false);
}
public static IEnumerable <CstNode> GetUppermostNodesByNames(CstNode cst, ISet <string> nodeNames)
{
return(cst.DescendantsAndSelf()
.Where(node => nodeNames.Contains(node.Name))
.Where(node => node.AncestorsWithSingleChild()
.All(ancestor => !nodeNames.Contains(ancestor.Name))));
}
public bool IsAcceptedUsingOracle(CstNode uppermostNode)
{
return(uppermostNode.DescendantsOfSingleAndSelf()
.Concat(uppermostNode.AncestorsWithSingleChild())
.Where(e => OracleNames.Contains(e.Name))
.Any(ProtectedIsAcceptedUsingOracle));
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
// blockStatement
// : localVariableDeclarationStatement
// | classOrInterfaceDeclaration
// | statement
// ;
if (node.Name == "blockStatement")
{
if (node.FirstChild.Name != "statement")
{
return(true);
}
node = node.FirstChild;
}
// ブロック自身は意味を持たないステートメントで、中身だけが必要なので除外
if (node.FirstChild.Name == "block")
{
return(false);
}
// ラベルを持つステートメントを除外
if (node.FirstChild.Name == "IDENTIFIER")
{
return(false);
}
if (node.FirstChild.TokenText == ";")
{
return(false);
}
return(true);
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
var p = node.Parent;
var pp = p.Parent;
var isPar = p.SafeName() == "parExpression";
var isStmt = pp.SafeName() == "statement";
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "if")
{
return(true);
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "while")
{
return(true);
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "do")
{
return(true);
}
if (p.SafeName() == "forstatement" &&
p.Children().Count(e2 => e2.TokenText == ";") >= 2)
{
return(true);
}
return(false);
}
public override CstNode GenerateTreeFromCode(
FileInfo codeFile, Encoding encoding = null,
bool throwingParseError = DefaultThrowingParseError)
{
var time = codeFile.LastWriteTime.ToString();
foreach (var invalidChar in Path.GetInvalidFileNameChars())
{
time = time.Replace(invalidChar, '_');
}
var cacheFileInfo =
new FileInfo(
codeFile.FullName + time + Code2XmlConstants.SyntaxTreeCacheExtension);
if (cacheFileInfo.Exists)
{
Console.WriteLine("Cached");
return(CstNode.Deserialize(cacheFileInfo));
}
var tree = DelegatingCstGenerator.GenerateTreeFromCode(
codeFile, encoding, throwingParseError);
tree.Serialize(cacheFileInfo);
Console.WriteLine("Saved");
return(tree);
}
// $ANTLR start synpred4_Test
private void synpred4_Test_fragment()
{
EnterRule_synpred4_Test_fragment();
EnterRule("synpred4_Test_fragment", 9);
var retval = new CstNode("synpred4_Test_fragment");
try
{
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Test\\Test.g:25:16: ( '*' primary )
DebugEnterAlt(1);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Test\\Test.g:25:16: '*' primary
{
DebugLocation(25, 16);
Match(input, 13, Follow._13_in_synpred4_Test131); if (state.failed)
{
return;
}
DebugLocation(25, 20);
PushFollow(Follow._primary_in_synpred4_Test133);
primary();
PopFollow();
if (state.failed)
{
return;
}
}
}
finally
{
TraceOut("synpred4_Test_fragment", 9);
LeaveRule("synpred4_Test_fragment", 9);
LeaveRule_synpred4_Test_fragment();
}
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
if (node.FirstChild.TokenText == ";")
{
return(true);
}
return(false);
}
/// <summary>
/// Find all the inner elements whose range overlapped with this range from the specified CstNode instance.
/// </summary>
/// <param name="root"></param>
/// <returns></returns>
public IEnumerable <CstNode> FindOverlappedNodes(CstNode root)
{
var thisRange = this;
// TODO: Should be more efficient
return(thisRange.FindOutermostNode(root).DescendantsAndSelf()
.Where(node => thisRange.Overlaps(Locate(node))));
}
public bool IsDoWhile(CstNode e)
{
// do { .. snip .. } while (cond);
CstNode p = e.Parent, pp = p.Parent;
return(p.Name == "parExpression" && pp.Name == "statement" &&
pp.FirstChild.TokenText == "do");
}
public bool IsFor(CstNode e)
{
// do { .. snip .. } while (cond);
var p = e.Parent;
return(p.Name == "forstatement" &&
p.Children().Count(e_ => e_.TokenText == ";") >= 2);
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
if (node.FirstChild.Name == "label")
{
return(true);
}
return(false);
}
public bool IsIf(CstNode e)
{
// if (cond) { .. snip .. }
CstNode p = e.Parent, pp = p.Parent;
return(p.Name == "parExpression" && pp.Name == "statement" &&
pp.FirstChild.TokenText == "if");
}
public static CstNode GetGoodAncestorNode(CstNode node)
{
while (node.Parent != null && node.Parent.Code.Length < 100)
{
node = node.Parent;
}
return(node);
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
if (node.Name == "small_stmt")
{
return(node.FirstChild.Name == "expr_stmt");
}
return(true);
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
if (node.Parent.Name == "switchStatement")
{
return(true);
}
return(node.Name == "caseClause" || node.Name == "defaultClause");
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
if (node.Name == "statement")
{
node = node.FirstChild;
}
return(node.Name == "expressionStatement");
}
public static HashSet <string> GetSurroundingPaths(
this CstNode node, HashSet <CstNode> surroundingNodes, FeatureExtractor extractor,
CstNode outermostNode)
{
var path = node.Name;
var paths = new HashSet <string>();
var ancestors = new Dictionary <CstNode, string> {
{ node, node.Name }
};
paths.Add(node.Name);
//paths.Add("'" + extractor.GetToken(node));
var ancestor = node.Ancestors().FirstOrDefault(a => a.Children().Count() > 1);
if (surroundingNodes.Contains(ancestor))
{
extractor.IsInner = false;
var originalNode = node;
path = node.Name + node.RuleId;
while ((node = node.Parent) != outermostNode)
{
ancestors.Add(node, path + "<" + node.Name);
path = path + "<" + node.Name + node.RuleId;
paths.Add(path);
}
path = path + "<" + node.Name; // must not have RuleId
paths.Add(path);
var index = 0;
foreach (var tokenNode in
originalNode.PreviousTokenNodes(node).Where(IsMeaningfulIdentifier))
{
if (!surroundingNodes.Contains(tokenNode))
{
break;
}
paths.Add("'-" + extractor.GetToken(tokenNode));
index++;
}
extractor.TokenLeft = Math.Max(extractor.TokenLeft, index);
index = 0;
foreach (var tokenNode in
originalNode.NextTokenNodes(node).Where(IsMeaningfulIdentifier))
{
if (!surroundingNodes.Contains(tokenNode))
{
break;
}
paths.Add("'+" + extractor.GetToken(tokenNode));
index++;
}
extractor.TokenRight = Math.Max(extractor.TokenRight, index);
}
GetSurroundingPaths(node, path, surroundingNodes, extractor, paths, ancestors);
return(paths);
}
public bool IsCheckArgument(CstNode e)
{
// Preconditions.checkArgument(cond, msg);
var primary = e.Parent.Parent.Parent.Parent;
return(primary.Name == "primary" &&
primary.Children().Any(e2 => e2.TokenText == "checkArgument") &&
!e.PrevsFromFirst().Any());
}
public void Create(CstNode parent, IToken token, string id) {
if (token != null) {
var count = token.TokenIndex;
var tokenName = DetermineElementName(token, Code2XmlConstants.TokenSetElementName);
var node = CreateTerminalNode(tokenName, token, token.Text, count, id);
parent.AddLast(node);
_nextTokenIndex = count + 1;
}
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
// ブロック自身は意味を持たないステートメントで、中身だけが必要なので除外
if (node.Child("bracketedBlock") != null)
{
return(true);
}
return(false);
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node)
{
// ラベルはループ文に付くため，ラベルの中身は除外
if (node.FirstChild.Name == "UnquotedString")
{
return(true);
}
return(false);
}
public Dictionary<CodeRange, CstNode> ExtractRange2Elements(CstNode ast) {
var elements = ExtractElements(ast);
// Elements having the same range can appear so can't use ToDictiornary
var ret = new Dictionary<CodeRange, CstNode>();
foreach (var element in elements) {
var range = CodeRange.Locate(element);
ret[range] = element;
}
return ret;
}
public IEnumerable<CstNode> ExtractElements(CstNode ast) {
foreach (var nameAndRules in FilterDictionary) {
var elements = ast.DescendantsAndSelf(nameAndRules.Key);
var rules = nameAndRules.Value;
var results = elements.Where(e => rules.All(rule => rule.IsAcceptable(e)));
foreach (var result in results) {
yield return result;
}
}
}
public CstNode FinishParsing(CstNode root) {
var count = _stream.Count - 1; // Avoid writing "<EOF>"
while (count > 0 && _stream.Get(count - 1).Type < 0) {
count--;
}
var antlrToken = _stream.Get(count);
var token = CreateTerminalNode(
Code2XmlConstants.EofTokenName, antlrToken, string.Empty, count,
Code2XmlConstants.EofRuleId);
root.AddLast(token);
return root;
}
private static List<SeedNode> CreateSeedNodes(StructuredCode structuredCode, CstNode cst, IEnumerable<SelectedFragment> fragments) {
var lastIndex = -1;
return fragments.Select(fragment => {
var startLineIndex = Math.Max(lastIndex + 1, structuredCode.GetIndex(fragment.StartLine, 0));
var surroundingIndex = structuredCode.Code.IndexOf(fragment.SurroundingText, startLineIndex);
var targetIndex = structuredCode.Code.IndexOf(fragment.TargetText, surroundingIndex);
if (surroundingIndex < 0 || targetIndex < 0) {
throw new Exception("The selected code fragment is invalid.");
}
var surroundingRange = structuredCode.GetRange(surroundingIndex,
surroundingIndex + fragment.SurroundingText.Length);
var targetRange = structuredCode.GetRange(targetIndex,
targetIndex + fragment.TargetText.Length);
var node = targetRange.FindOutermostNode(cst);
lastIndex = surroundingIndex;
return new SeedNode(node, targetRange, surroundingRange);
}).ToList();
}
public bool IsCheckArgument(CstNode e) {
// Preconditions.checkArgument(cond, msg);
var primary = e.Parent.Parent.Parent.Parent;
return primary.Name == "primary"
&& primary.Children().Any(e2 => e2.TokenText == "checkArgument")
&& !e.PrevsFromFirst().Any();
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node) {
var p = node.Parent;
var pp = p.Parent;
var isPar = p.SafeName() == "parExpression";
var isStmt = pp.SafeName() == "statement";
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "switch") {
return true;
}
return node.Name == "switchLabel";
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node) {
return node.FirstChild.Name == "expression";
}
public bool IsEmptyStatement(CstNode e) {
// ;
return e.TokenText == ";";
}
public bool IsClassDeclaration(CstNode e) {
// class A {}
return e.FirstChild.Name == "classOrInterfaceDeclaration";
}
/*
blockStatement
: localVariableDeclarationStatement
| classOrInterfaceDeclaration
| statement
;
statement
: block
| ';'
| IDENTIFIER ':' statement
| expression ';'
| ... (snip) ...
;
*/
public IEnumerable<CstNode> SelectStatements(CstNode e) {
var blockStatements = e.Descendants("blockStatement")
.Where(e_ => IsVariableDeclaration(e_) || IsClassDeclaration(e_));
var statements = e.Descendants("statement")
.Where(
e_ =>
!IsBlockStatement(e_) && !IsEmptyStatement(e_)
&& !IsLabeledStatement(e_));
return blockStatements.Concat(statements);
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node) {
var p = node.Parent;
var pp = p.Parent;
var isPar = p.SafeName() == "parExpression";
var isStmt = pp.SafeName() == "statement";
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "if") {
return true;
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "while") {
return true;
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "do") {
return true;
}
if (p.SafeName() == "forstatement"
&& p.Children().Count(e2 => e2.TokenText == ";") >= 2) {
return true;
}
{
var primary = node.SafeParent().SafeParent().SafeParent().SafeParent();
if (primary.SafeName() != "primary") {
return false;
}
//if (primary.Elements().All(e2 => e2.TokenText() != "Preconditions")) {
// return false;
//}
if (primary.Children().All(e2 => e2.TokenText != "checkArgument")) {
return false;
}
//if (primary.NthElementOrDefault(0).SafeTokenText() != "Preconditions") {
// return false;
//}
//if (primary.NthElementOrDefault(2).SafeTokenText() != "checkArgument") {
// return false;
//}
if (node.PrevsFromFirst().Any()) {
return false;
}
return true;
}
}
private static void ConvertIndiciesToRange(
CstNode node, string code, int inclusiveStart, int exclusiveEnd, CodeRange range) {
var newRange = CodeRange.ConvertFromIndicies(code, inclusiveStart, exclusiveEnd);
var newInclusiveStart = char.IsWhiteSpace(code[inclusiveStart - 1])
? inclusiveStart - 1 : inclusiveStart;
var newExclusiveEnd = char.IsWhiteSpace(code[exclusiveEnd])
? exclusiveEnd + 1 : exclusiveEnd;
var elem = CodeRange.ConvertFromIndiciesSkippingWhitespaces(
code, ref newInclusiveStart, ref newExclusiveEnd)
.FindInnermostNode(node);
Assert.That(CodeRange.Locate(elem), Is.EqualTo(newRange));
newRange.ConvertToIndicies(code, out newInclusiveStart, out newExclusiveEnd);
Assert.That(newRange, Is.EqualTo(range));
Assert.That(newInclusiveStart, Is.EqualTo(inclusiveStart));
Assert.That(newExclusiveEnd, Is.EqualTo(exclusiveEnd));
var scode = new StructuredCode(code);
Assert.That(
CodeRange.ConvertFromIndicies(scode, inclusiveStart, exclusiveEnd),
Is.EqualTo(range));
newRange.ConvertToIndicies(scode, out newInclusiveStart, out newExclusiveEnd);
Assert.That(newInclusiveStart, Is.EqualTo(inclusiveStart));
Assert.That(newExclusiveEnd, Is.EqualTo(exclusiveEnd));
}
private static CodeRange ConvertRangeToIndicies(
string code, CstNode node, out int inclusiveStart, out int exclusiveEnd) {
var range = CodeRange.Locate(node);
range.ConvertToIndicies(code, out inclusiveStart, out exclusiveEnd);
Assert.That(
code.Substring(inclusiveStart, exclusiveEnd - inclusiveStart),
Is.EqualTo(node.Code.Trim()));
range.ConvertToIndicies(new StructuredCode(code), out inclusiveStart, out exclusiveEnd);
Assert.That(
code.Substring(inclusiveStart, exclusiveEnd - inclusiveStart),
Is.EqualTo(node.Code.Trim()));
return range;
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node) {
var p = node.Parent;
var pp = p.Parent;
var isPar = p.SafeName() == "parExpression";
var isStmt = pp.SafeName() == "statement";
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "if") {
return true;
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "while") {
return true;
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "do") {
return true;
}
if (p.SafeName() == "forstatement"
&& p.Children().Count(e2 => e2.TokenText == ";") >= 2) {
return true;
}
return false;
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node) {
// blockStatement
// : localVariableDeclarationStatement
// | classOrInterfaceDeclaration
// | statement
// ;
if (node.Name == "blockStatement") {
if (node.FirstChild.Name != "statement") {
return true;
}
node = node.FirstChild;
}
// ブロック自身は意味を持たないステートメントで、中身だけが必要なので除外
if (node.FirstChild.Name == "block") {
return false;
}
// ラベルを持つステートメントを除外
if (node.FirstChild.Name == "IDENTIFIER") {
return false;
}
if (node.FirstChild.TokenText == ";") {
return false;
}
return true;
}
public IEnumerable<CstNode> SelectBooleanExpressions(CstNode e) {
var expressions = e.Descendants("expression")
.Where(
e_ => IsIf(e_) || IsWhile(e_) ||
IsDoWhile(e_) || IsFor(e_) || IsCheckArgument(e_))
.Where(e_ => !IsChild(e_, IsCatchBlock));
return expressions;
}
public bool IsVariableDeclaration(CstNode e) {
// int value = 0;
return e.FirstChild.Name == "localVariableDeclarationStatement";
}
public bool IsCatchBlock(CstNode e) {
// catch { .. snip .. }
return e.Name == "block" && e.Parent.Name == "catchClause";
}
public bool IsBlockStatement(CstNode e) {
// { int value = 0; }
return e.FirstChild.Name == "block";
}
public bool IsChild(CstNode e, Func<CstNode, bool> isCatchBlock) {
return e.Ancestors().Any(isCatchBlock);
}
public bool IsLabeledStatement(CstNode e) {
// LABEL: should_be_ignored();
return e.FirstChild.Name == "IDENTIFIER";
}
public bool IsIf(CstNode e) {
// if (cond) { .. snip .. }
CstNode p = e.Parent, pp = p.Parent;
return p.Name == "parExpression" && pp.Name == "statement"
&& pp.FirstChild.TokenText == "if";
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node) {
return ((node.TokenText == "+" || node.TokenText == "-")
&& node.Parent.Name == "additiveExpression") ||
((node.TokenText == "*" || node.TokenText == "/")
&& node.Parent.Name == "multiplicativeExpression");
}
public bool IsDoWhile(CstNode e) {
// do { .. snip .. } while (cond);
CstNode p = e.Parent, pp = p.Parent;
return p.Name == "parExpression" && pp.Name == "statement"
&& pp.FirstChild.TokenText == "do";
}
public override bool ProtectedIsAcceptedUsingOracle(CstNode node) {
var p = node.Parent;
var pp = p.Parent;
var isPar = p.SafeName() == "parExpression";
var isStmt = pp.SafeName() == "statement";
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "if") {
return node.TokenText != "true";
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "while") {
return node.TokenText != "true";
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "do") {
return node.TokenText != "true";
}
if (p.SafeName() == "forstatement"
&& p.Children().Count(e2 => e2.TokenText == ";") >= 2) {
return node.TokenText != "true";
}
if (isStmt && isPar && pp.FirstChild.SafeTokenText() == "switch") {
return true;
}
if (node.Name == "switchLabel") {
return true;
}
{
var primary = node.SafeParent().SafeParent().SafeParent().SafeParent();
if (primary.SafeName() != "primary") {
return false;
}
if (primary.Children().All(e2 => e2.TokenText != "checkArgument")) {
return false;
}
if (node.PrevsFromFirst().Any()) {
return false;
}
return node.TokenText != "true";
}
}
public bool IsFor(CstNode e) {
// do { .. snip .. } while (cond);
var p = e.Parent;
return p.Name == "forstatement"
&& p.Children().Count(e_ => e_.TokenText == ";") >= 2;
}
public static void Create(
CstNode root, List<SelectedFragment> acceptingFragments,
LearningExperiment learningExperiment) {
foreach (var fragment in acceptingFragments) {
var rootNode = fragment.SurroundingRange.FindInnermostNode(root);
var node = fragment.Node;
var paths = new HashSet<string>();
var path = node.Name;
paths.Add(path);
while ((node = node.Parent) != rootNode) {
path = path + "<" + node.Name + node.RuleId;
paths.Add(path);
}
}
}
private CstNode listVariables()
{
EnterRule_listVariables();
EnterRule("listVariables", 43);
var retval = new CstNode("listVariables");
var retval_Start = (IToken)input.LT(1);
int listVariables_StartIndex = input.Index;
object root_0 = default(object);
IToken List299 = default(IToken);
IToken OpenRoundBracket300 = default(IToken);
IToken char_literal302 = default(IToken);
IToken CloseRoundBracket304 = default(IToken);
CstNode name301 = default(CstNode);
CstNode name303 = default(CstNode);
CstNode name305 = default(CstNode);
object List299_tree = default(object);
object OpenRoundBracket300_tree = default(object);
object char_literal302_tree = default(object);
object CloseRoundBracket304_tree = default(object);
try { DebugEnterRule(GrammarFileName, "listVariables");
DebugLocation(305, 1);
try
{
if (state.backtracking > 0 && AlreadyParsedRule(input, 43)) { return retval; }
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:2: ( List OpenRoundBracket ( name )? ( ',' ( name )? )* CloseRoundBracket | name )
int alt86=2;
try { DebugEnterDecision(86, false);
int LA86_1 = input.LA(1);
if ((LA86_1==List))
{
int LA86_2 = input.LA(2);
if ((EvaluatePredicate(synpred125_Php_fragment)))
{
alt86 = 1;
}
else if ((true))
{
alt86 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 86, 1, input, 2);
DebugRecognitionException(nvae);
throw nvae;
}
}
else if ((LA86_1==Abstract||LA86_1==And||LA86_1==As||(LA86_1>=BoolType && LA86_1<=Class)||LA86_1==Clone||(LA86_1>=Const && LA86_1<=Continue)||(LA86_1>=Default && LA86_1<=Die)||LA86_1==Do||(LA86_1>=DoubleType && LA86_1<=Empty)||(LA86_1>=Eval && LA86_1<=Exit)||(LA86_1>=Extends && LA86_1<=Foreach)||(LA86_1>=Function && LA86_1<=HaltCompiler)||(LA86_1>=If && LA86_1<=IncludeOnce)||(LA86_1>=Instanceof && LA86_1<=IntType)||(LA86_1>=IntegerType && LA86_1<=Isset)||(LA86_1>=Namespace && LA86_1<=Null)||LA86_1==ObjectType||LA86_1==Or||(LA86_1>=Print && LA86_1<=Public)||(LA86_1>=RealType && LA86_1<=Return)||(LA86_1>=Static && LA86_1<=StringType)||(LA86_1>=Switch && LA86_1<=Throw)||(LA86_1>=True && LA86_1<=Try)||LA86_1==UnquotedString||(LA86_1>=Use && LA86_1<=While)||(LA86_1>=Xor && LA86_1<=131)))
{
alt86 = 2;
}
else
{
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae = new NoViableAltException("", 86, 0, input, 1);
DebugRecognitionException(nvae);
throw nvae;
}
} finally { DebugExitDecision(86); }
switch (alt86)
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:4: List OpenRoundBracket ( name )? ( ',' ( name )? )* CloseRoundBracket
{
DebugLocation(306, 4);
List299=(IToken)Match(input,List,Follow._List_in_listVariables1648); if (state.failed) return retval;
if (state.backtracking == 0) {
adaptor.Create(retval, List299, "List299");
}
DebugLocation(306, 9);
OpenRoundBracket300=(IToken)Match(input,OpenRoundBracket,Follow._OpenRoundBracket_in_listVariables1650); if (state.failed) return retval;
if (state.backtracking == 0) {
adaptor.Create(retval, OpenRoundBracket300, "OpenRoundBracket300");
}
DebugLocation(306, 26);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:26: ( name )?
int alt83=2;
try { DebugEnterSubRule(83);
try { DebugEnterDecision(83, false);
int LA83_1 = input.LA(1);
if ((LA83_1==Abstract||LA83_1==And||LA83_1==As||(LA83_1>=BoolType && LA83_1<=Class)||LA83_1==Clone||(LA83_1>=Const && LA83_1<=Continue)||(LA83_1>=Default && LA83_1<=Die)||LA83_1==Do||(LA83_1>=DoubleType && LA83_1<=Empty)||(LA83_1>=Eval && LA83_1<=Exit)||(LA83_1>=Extends && LA83_1<=Foreach)||(LA83_1>=Function && LA83_1<=HaltCompiler)||(LA83_1>=If && LA83_1<=IncludeOnce)||(LA83_1>=Instanceof && LA83_1<=IntType)||(LA83_1>=IntegerType && LA83_1<=List)||(LA83_1>=Namespace && LA83_1<=Null)||LA83_1==ObjectType||LA83_1==Or||(LA83_1>=Print && LA83_1<=Public)||(LA83_1>=RealType && LA83_1<=Return)||(LA83_1>=Static && LA83_1<=StringType)||(LA83_1>=Switch && LA83_1<=Throw)||(LA83_1>=True && LA83_1<=Try)||LA83_1==UnquotedString||(LA83_1>=Use && LA83_1<=While)||(LA83_1>=Xor && LA83_1<=131)))
{
alt83 = 1;
}
} finally { DebugExitDecision(83); }
switch (alt83)
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:26: name
{
DebugLocation(306, 26);
PushFollow(Follow._name_in_listVariables1652);
name301=name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(retval, name301, "name301");
}
break;
}
} finally { DebugExitSubRule(83); }
DebugLocation(306, 32);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:32: ( ',' ( name )? )*
try { DebugEnterSubRule(85);
while (true)
{
int alt85=2;
try { DebugEnterDecision(85, false);
int LA85_1 = input.LA(1);
if ((LA85_1==Comma))
{
alt85 = 1;
}
} finally { DebugExitDecision(85); }
switch ( alt85 )
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:33: ',' ( name )?
{
DebugLocation(306, 33);
char_literal302=(IToken)Match(input,Comma,Follow._Comma_in_listVariables1656); if (state.failed) return retval;
if (state.backtracking == 0) {
adaptor.Create(retval, char_literal302, "char_literal302");
}
DebugLocation(306, 37);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:37: ( name )?
int alt84=2;
try { DebugEnterSubRule(84);
try { DebugEnterDecision(84, false);
int LA84_1 = input.LA(1);
if ((LA84_1==Abstract||LA84_1==And||LA84_1==As||(LA84_1>=BoolType && LA84_1<=Class)||LA84_1==Clone||(LA84_1>=Const && LA84_1<=Continue)||(LA84_1>=Default && LA84_1<=Die)||LA84_1==Do||(LA84_1>=DoubleType && LA84_1<=Empty)||(LA84_1>=Eval && LA84_1<=Exit)||(LA84_1>=Extends && LA84_1<=Foreach)||(LA84_1>=Function && LA84_1<=HaltCompiler)||(LA84_1>=If && LA84_1<=IncludeOnce)||(LA84_1>=Instanceof && LA84_1<=IntType)||(LA84_1>=IntegerType && LA84_1<=List)||(LA84_1>=Namespace && LA84_1<=Null)||LA84_1==ObjectType||LA84_1==Or||(LA84_1>=Print && LA84_1<=Public)||(LA84_1>=RealType && LA84_1<=Return)||(LA84_1>=Static && LA84_1<=StringType)||(LA84_1>=Switch && LA84_1<=Throw)||(LA84_1>=True && LA84_1<=Try)||LA84_1==UnquotedString||(LA84_1>=Use && LA84_1<=While)||(LA84_1>=Xor && LA84_1<=131)))
{
alt84 = 1;
}
} finally { DebugExitDecision(84); }
switch (alt84)
{
case 1:
DebugEnterAlt(1);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:306:37: name
{
DebugLocation(306, 37);
PushFollow(Follow._name_in_listVariables1658);
name303=name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(retval, name303, "name303");
}
break;
}
} finally { DebugExitSubRule(84); }
}
break;
default:
goto loop85;
}
}
loop85:
;
} finally { DebugExitSubRule(85); }
DebugLocation(306, 45);
CloseRoundBracket304=(IToken)Match(input,CloseRoundBracket,Follow._CloseRoundBracket_in_listVariables1663); if (state.failed) return retval;
if (state.backtracking == 0) {
adaptor.Create(retval, CloseRoundBracket304, "CloseRoundBracket304");
}
}
break;
case 2:
DebugEnterAlt(2);
// C:\\Users\\exKAZUu\\Projects\\Code2Xml\\Code2Xml.Core\\Generators\\ANTLRv3\\Php\\Php.g:307:4: name
{
DebugLocation(307, 4);
PushFollow(Follow._name_in_listVariables1669);
name305=name();
PopFollow();
if (state.failed) return retval;
if (state.backtracking == 0) adaptor.AddChild(retval, name305, "name305");
}
break;
}
if (state.backtracking == 0) {
}
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
adaptor.ErrorNode(input, retval_Start, input.LT(-1), re);
}
finally
{
TraceOut("listVariables", 43);
LeaveRule("listVariables", 43);
LeaveRule_listVariables();
if (state.backtracking > 0) { Memoize(input, 43, listVariables_StartIndex); }
}
DebugLocation(308, 1);
} finally { DebugExitRule(GrammarFileName, "listVariables"); }
return retval;
}
