// $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 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; }