private void DumpOnEntereringSequence(Sequence seq) { if (seq.SequenceType == SequenceType.RuleCall || seq.SequenceType == SequenceType.RuleAllCall || seq.SequenceType == SequenceType.RuleCountAllCall) { curRule = (SequenceRuleCall)seq; if (curRule.Special) { impl.curShellProcEnv.ProcEnv.OnFinishing += DumpOnFinishing; } } }
private void NormalEnteringSequenceHandler(Sequence seq) { if (cancelSequence) { Cancel(); } if (seq.SequenceType == SequenceType.RuleCall || seq.SequenceType == SequenceType.RuleAllCall || seq.SequenceType == SequenceType.RuleCountAllCall) { curRule = (SequenceRuleCall)seq; } }
public SequenceRuleCallMatcherGenerator(SequenceRuleCall seqRule, SequenceExpressionGenerator seqExprGen, SequenceGeneratorHelper seqHelper) { this.seqRule = seqRule; this.seqExprGen = seqExprGen; this.seqHelper = seqHelper; ArgumentExpressions = seqRule.ArgumentExpressions; String matchingPatternClassName = "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Rule_" + seqRule.Name; patternName = seqRule.Name; ruleName = "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name); matchType = matchingPatternClassName + "." + NamesOfEntities.MatchInterfaceName(patternName); matchesType = "GRGEN_LIBGR.IMatchesExact<" + matchType + ">"; matchesName = "matches_" + seqRule.Id; }
private void DumpOnExitingSequence(Sequence seq) { if (seq.SequenceType == SequenceType.RuleCall || seq.SequenceType == SequenceType.RuleAllCall || seq.SequenceType == SequenceType.RuleCountAllCall) { SequenceRuleCall ruleSeq = (SequenceRuleCall)seq; if (ruleSeq != null && ruleSeq.Special) { impl.curShellProcEnv.ProcEnv.OnFinishing -= DumpOnFinishing; } } if (cancelSequence) { Cancel(); } }
public SequenceSomeRuleCallRewritingGenerator(SequenceSomeFromSet seqSome, SequenceRuleCall seqRule, SequenceExpressionGenerator seqExprGen, SequenceGeneratorHelper seqHelper) { this.seqSome = seqSome; // parent this.seqExprGen = seqExprGen; this.seqHelper = seqHelper; this.seqRule = seqRule; specialStr = seqRule.Special ? "true" : "false"; matchingPatternClassName = "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Rule_" + seqRule.Name; patternName = seqRule.Name; ruleName = "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name); matchType = matchingPatternClassName + "." + NamesOfEntities.MatchInterfaceName(patternName); matchName = "match_" + seqRule.Id; matchesType = "GRGEN_LIBGR.IMatchesExact<" + matchType + ">"; matchesName = "matches_" + seqRule.Id; }
public SequenceBacktrackGenerator(SequenceBacktrack seq, SequenceExpressionGenerator seqExprGen, SequenceGeneratorHelper seqHelper) { this.seq = seq; this.seqExprGen = seqExprGen; this.seqHelper = seqHelper; seqRule = seq.Rule; ArgumentExpressions = seqRule.ArgumentExpressions; ReturnVars = seqRule.ReturnVars; specialStr = seqRule.Special ? "true" : "false"; matchingPatternClassName = "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Rule_" + seqRule.Name; patternName = seqRule.Name; ruleName = "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name); matchType = matchingPatternClassName + "." + NamesOfEntities.MatchInterfaceName(patternName); matchName = "match_" + seq.Id; matchesType = "GRGEN_LIBGR.IMatchesExact<" + matchType + ">"; matchesName = "matches_" + seq.Id; }
/// <summary> /// Helper for checking rule calls. /// Type checks the input, type checks the output. /// Throws an exception when an error is found. /// </summary> /// <param name="seqRuleCall">The rule call to check</param> public void CheckRuleCall(SequenceRuleCall seqRuleCall) { CheckInputParameters(seqRuleCall, seqRuleCall.ArgumentExpressions, null); if (seqRuleCall.IsRuleForMultiRuleAllCallReturningArrays) { CheckOutputParametersRuleAll(seqRuleCall, seqRuleCall.ReturnVars); } else { CheckOutputParameters(seqRuleCall, seqRuleCall.ReturnVars, null); } CheckFilterCalls(seqRuleCall.Name, seqRuleCall.Filters); CheckSubgraph(seqRuleCall); // ok, this is a well-formed invocation }
public SequenceMultiBacktrackRuleRewritingGenerator(SequenceMultiBacktrack seqMulti, SequenceRuleCall seqRule, SequenceExpressionGenerator seqExprGen, SequenceGeneratorHelper seqHelper) { this.seqMulti = seqMulti; this.seqExprGen = seqExprGen; this.seqHelper = seqHelper; this.seqRule = seqRule; ReturnVars = seqRule.ReturnVars; specialStr = seqRule.Special ? "true" : "false"; matchingPatternClassName = "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Rule_" + seqRule.Name; patternName = seqRule.Name; plainRuleName = TypesHelper.PackagePrefixedNameDoubleColon(seqRule.Package, seqRule.Name); ruleName = "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name); matchType = matchingPatternClassName + "." + NamesOfEntities.MatchInterfaceName(patternName); matchName = "match_" + seqRule.Id; matchesType = "GRGEN_LIBGR.IMatchesExact<" + matchType + ">"; matchesName = "matches_" + seqRule.Id; }
public SequenceMultiRuleAllCallGenerator(SequenceMultiRuleAllCall seqMulti, SequenceRuleCall seqRule, SequenceExpressionGenerator seqExprGen, SequenceGeneratorHelper seqHelper) { this.seqMulti = seqMulti; // parent this.seqRule = seqRule; this.seqExprGen = seqExprGen; this.seqHelper = seqHelper; ArgumentExpressions = seqRule.ArgumentExpressions; specialStr = seqRule.Special ? "true" : "false"; matchingPatternClassName = "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Rule_" + seqRule.Name; patternName = seqRule.Name; plainRuleName = TypesHelper.PackagePrefixedNameDoubleColon(seqRule.Package, seqRule.Name); ruleName = "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name); matchType = matchingPatternClassName + "." + NamesOfEntities.MatchInterfaceName(patternName); matchName = "match_" + seqRule.Id; matchesType = "GRGEN_LIBGR.IMatchesExact<" + matchType + ">"; matchesName = "matches_" + seqRule.Id; seqHelper.BuildReturnParameters(seqRule, seqRule.ReturnVars, out returnParameterDeclarations, out returnArguments, out returnAssignments, out returnParameterDeclarationsAllCall, out intermediateReturnAssignmentsAllCall, out returnAssignmentsAllCall); }
/// <summary> /// pre-run for emitting the needed entities before emitting the real code /// - emits result variable declarations /// - emits sequence variable declarations (only once for every variable, declaration only possible at assignment targets) /// - collects used rules into knownRules, emit local rule declaration (only once for every rule) /// </summary> public void EmitNeededVarAndRuleEntities(Sequence seq, SourceBuilder source) { source.AppendFront(COMP_HELPER.DeclareResultVar(seq)); switch (seq.SequenceType) { case SequenceType.AssignUserInputToVar: case SequenceType.AssignRandomIntToVar: case SequenceType.AssignRandomDoubleToVar: case SequenceType.DeclareVariable: case SequenceType.AssignConstToVar: case SequenceType.AssignContainerConstructorToVar: case SequenceType.AssignVarToVar: { SequenceAssignToVar toVar = (SequenceAssignToVar)seq; EmitVarIfNew(toVar.DestVar, source); break; } case SequenceType.AssignSequenceResultToVar: case SequenceType.OrAssignSequenceResultToVar: case SequenceType.AndAssignSequenceResultToVar: { SequenceAssignSequenceResultToVar seqToVar = (SequenceAssignSequenceResultToVar)seq; EmitVarIfNew(seqToVar.DestVar, source); EmitNeededVarAndRuleEntities(seqToVar.Seq, source); break; } case SequenceType.RuleCall: case SequenceType.RuleAllCall: case SequenceType.RuleCountAllCall: { SequenceRuleCall seqRule = (SequenceRuleCall)seq; String ruleName = seqRule.PackagePrefixedName; if (!knownRules.ContainsKey(ruleName)) { knownRules.Add(ruleName, null); source.AppendFront("GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Action_" + seqRule.Name + " " + "rule_" + TypesHelper.PackagePrefixedNameUnderscore(seqRule.Package, seqRule.Name)); source.Append(" = " + "GRGEN_ACTIONS." + TypesHelper.GetPackagePrefixDot(seqRule.Package) + "Action_" + seqRule.Name + ".Instance;\n"); } // no handling for the input arguments seqRule.ArgumentExpressions needed // because there can only be variable uses for (int i = 0; i < seqRule.ReturnVars.Length; ++i) { EmitVarIfNew(seqRule.ReturnVars[i], source); } if (seq.SequenceType == SequenceType.RuleCountAllCall) { SequenceRuleCountAllCall seqCountRuleAll = (SequenceRuleCountAllCall)seqRule; EmitVarIfNew(seqCountRuleAll.CountResult, source); } break; } case SequenceType.SequenceCall: { SequenceSequenceCall seqSeq = (SequenceSequenceCall)seq; // no handling for the input arguments seqSeq.ArgumentExpressions or the optional Subgraph needed // because there can only be variable uses for (int i = 0; i < seqSeq.ReturnVars.Length; ++i) { EmitVarIfNew(seqSeq.ReturnVars[i], source); } break; } case SequenceType.ForContainer: { SequenceForContainer seqFor = (SequenceForContainer)seq; EmitVarIfNew(seqFor.Var, source); if (seqFor.VarDst != null) { EmitVarIfNew(seqFor.VarDst, source); } EmitNeededVarAndRuleEntities(seqFor.Seq, source); break; } case SequenceType.ForIntegerRange: { SequenceForIntegerRange seqFor = (SequenceForIntegerRange)seq; EmitVarIfNew(seqFor.Var, source); EmitNeededVarAndRuleEntities(seqFor.Seq, source); break; } case SequenceType.ForIndexAccessEquality: { SequenceForIndexAccessEquality seqFor = (SequenceForIndexAccessEquality)seq; EmitVarIfNew(seqFor.Var, source); EmitNeededVarAndRuleEntities(seqFor.Seq, source); break; } case SequenceType.ForIndexAccessOrdering: { SequenceForIndexAccessOrdering seqFor = (SequenceForIndexAccessOrdering)seq; EmitVarIfNew(seqFor.Var, source); EmitNeededVarAndRuleEntities(seqFor.Seq, source); break; } case SequenceType.ForAdjacentNodes: case SequenceType.ForAdjacentNodesViaIncoming: case SequenceType.ForAdjacentNodesViaOutgoing: case SequenceType.ForIncidentEdges: case SequenceType.ForIncomingEdges: case SequenceType.ForOutgoingEdges: case SequenceType.ForReachableNodes: case SequenceType.ForReachableNodesViaIncoming: case SequenceType.ForReachableNodesViaOutgoing: case SequenceType.ForReachableEdges: case SequenceType.ForReachableEdgesViaIncoming: case SequenceType.ForReachableEdgesViaOutgoing: case SequenceType.ForBoundedReachableNodes: case SequenceType.ForBoundedReachableNodesViaIncoming: case SequenceType.ForBoundedReachableNodesViaOutgoing: case SequenceType.ForBoundedReachableEdges: case SequenceType.ForBoundedReachableEdgesViaIncoming: case SequenceType.ForBoundedReachableEdgesViaOutgoing: case SequenceType.ForNodes: case SequenceType.ForEdges: { SequenceForFunction seqFor = (SequenceForFunction)seq; EmitVarIfNew(seqFor.Var, source); EmitNeededVarAndRuleEntities(seqFor.Seq, source); break; } case SequenceType.ForMatch: { SequenceForMatch seqFor = (SequenceForMatch)seq; EmitVarIfNew(seqFor.Var, source); EmitNeededVarAndRuleEntities(seqFor.Seq, source); EmitNeededVarAndRuleEntities(seqFor.Rule, source); break; } case SequenceType.BooleanComputation: { SequenceBooleanComputation seqBoolComp = (SequenceBooleanComputation)seq; EmitNeededVarEntities(seqBoolComp.Computation, source); break; } default: foreach (Sequence childSeq in seq.Children) { EmitNeededVarAndRuleEntities(childSeq, source); } break; } }
public void ApplyRewriteSequence(Sequence seq, bool debug) { bool installedDumpHandlers = false; if (!impl.ActionsExists()) { return; } if (debug || CheckDebuggerAlive()) { debugger.NotifyOnConnectionLost = true; debugger.InitNewRewriteSequence(seq, debug); } if (!InDebugMode && ContainsSpecial(seq)) { impl.curShellProcEnv.ProcEnv.OnEntereringSequence += DumpOnEntereringSequence; impl.curShellProcEnv.ProcEnv.OnExitingSequence += DumpOnExitingSequence; installedDumpHandlers = true; } else { impl.curShellProcEnv.ProcEnv.OnEntereringSequence += NormalEnteringSequenceHandler; } curGRS = seq; curRule = null; impl.debugOut.WriteLine("Executing Graph Rewrite Sequence (CTRL+C for abort) ..."); cancelSequence = false; WorkaroundManager.Workaround.PreventComputerGoingIntoSleepMode(true); impl.curShellProcEnv.ProcEnv.PerformanceInfo.Reset(); StatisticsSource statisticsSource = new StatisticsSource(impl.curShellProcEnv.ProcEnv.NamedGraph, impl.curShellProcEnv.ProcEnv); Timer timer = null; if (!debug && !silenceExec) { timer = new Timer(new TimerCallback(PrintStatistics), statisticsSource, 1000, 1000); } try { bool result = impl.curShellProcEnv.ProcEnv.ApplyGraphRewriteSequence(seq); if (timer != null) { timer.Dispose(); } seq.ResetExecutionState(); impl.debugOut.WriteLine("Executing Graph Rewrite Sequence done after {0} ms with result: {1}", (impl.curShellProcEnv.ProcEnv.PerformanceInfo.TimeNeeded * 1000).ToString("F1", System.Globalization.CultureInfo.InvariantCulture), result); if (impl.newGraphOptions.Profile) { impl.debugOut.WriteLine(" - {0} search steps executed", impl.curShellProcEnv.ProcEnv.PerformanceInfo.SearchSteps); } #if DEBUGACTIONS || MATCHREWRITEDETAIL // spread over multiple files now, search for the corresponding defines to reactivate impl.debugOut.WriteLine(" - {0} matches found in {1} ms", perfInfo.MatchesFound, perfInfo.TotalMatchTimeMS); impl.debugOut.WriteLine(" - {0} rewrites performed in {1} ms", perfInfo.RewritesPerformed, perfInfo.TotalRewriteTimeMS); #if DEBUGACTIONS impl.debugOut.WriteLine("\nDetails:"); ShowSequenceDetails(seq, perfInfo); #endif #else impl.debugOut.WriteLine(" - {0} matches found", impl.curShellProcEnv.ProcEnv.PerformanceInfo.MatchesFound); impl.debugOut.WriteLine(" - {0} rewrites performed", impl.curShellProcEnv.ProcEnv.PerformanceInfo.RewritesPerformed); #endif } catch (OperationCanceledException) { cancelSequence = true; // make sure cancelSequence is set to true if (timer != null) { timer.Dispose(); } if (curRule == null) { impl.errOut.WriteLine("Rewrite sequence aborted!"); } else { impl.errOut.WriteLine("Rewrite sequence aborted after position:"); SequencePrinter.PrintSequence(curGRS, curRule); impl.errOut.WriteLine(); } } WorkaroundManager.Workaround.PreventComputerGoingIntoSleepMode(false); curRule = null; curGRS = null; if (InDebugMode) { debugger.NotifyOnConnectionLost = false; debugger.FinishRewriteSequence(); } StreamWriter emitWriter = impl.curShellProcEnv.ProcEnv.EmitWriter as StreamWriter; if (emitWriter != null) { emitWriter.Flush(); } if (installedDumpHandlers) { impl.curShellProcEnv.ProcEnv.OnEntereringSequence -= DumpOnEntereringSequence; impl.curShellProcEnv.ProcEnv.OnExitingSequence -= DumpOnExitingSequence; } else { impl.curShellProcEnv.ProcEnv.OnEntereringSequence -= NormalEnteringSequenceHandler; } }
public void ApplyRewriteSequenceExpression(SequenceExpression seqExpr) { SequenceDummy seq = new SequenceDummy(); if (!impl.ActionsExists()) { return; } if (CheckDebuggerAlive()) { debugger.NotifyOnConnectionLost = true; debugger.InitNewRewriteSequence(seq, false); } curGRS = seq; curRule = null; impl.debugOut.WriteLine("Evaluating Sequence Expression (CTRL+C for abort) ..."); cancelSequence = false; WorkaroundManager.Workaround.PreventComputerGoingIntoSleepMode(true); impl.curShellProcEnv.ProcEnv.PerformanceInfo.Reset(); StatisticsSource statisticsSource = new StatisticsSource(impl.curShellProcEnv.ProcEnv.NamedGraph, impl.curShellProcEnv.ProcEnv); Timer timer = null; if (!silenceExec) { timer = new Timer(new TimerCallback(PrintStatistics), statisticsSource, 1000, 1000); } try { object result = impl.curShellProcEnv.ProcEnv.EvaluateGraphRewriteSequenceExpression(seqExpr); if (timer != null) { timer.Dispose(); } seq.ResetExecutionState(); impl.debugOut.WriteLine("Evaluating Sequence Expression done after {0} ms with result: {1}", (impl.curShellProcEnv.ProcEnv.PerformanceInfo.TimeNeeded * 1000).ToString("F1", System.Globalization.CultureInfo.InvariantCulture), EmitHelper.ToStringAutomatic(result, impl.curShellProcEnv.ProcEnv.Graph)); if (impl.newGraphOptions.Profile) { impl.debugOut.WriteLine(" - {0} search steps executed", impl.curShellProcEnv.ProcEnv.PerformanceInfo.SearchSteps); } #if DEBUGACTIONS || MATCHREWRITEDETAIL // spread over multiple files now, search for the corresponding defines to reactivate impl.debugOut.WriteLine(" - {0} matches found in {1} ms", perfInfo.MatchesFound, perfInfo.TotalMatchTimeMS); impl.debugOut.WriteLine(" - {0} rewrites performed in {1} ms", perfInfo.RewritesPerformed, perfInfo.TotalRewriteTimeMS); #if DEBUGACTIONS impl.debugOut.WriteLine("\nDetails:"); ShowSequenceDetails(seq, perfInfo); #endif #else impl.debugOut.WriteLine(" - {0} matches found", impl.curShellProcEnv.ProcEnv.PerformanceInfo.MatchesFound); #endif } catch (OperationCanceledException) { cancelSequence = true; // make sure cancelSequence is set to true if (timer != null) { timer.Dispose(); } impl.errOut.WriteLine("Sequence expression aborted!"); } WorkaroundManager.Workaround.PreventComputerGoingIntoSleepMode(false); curRule = null; curGRS = null; if (InDebugMode) { debugger.NotifyOnConnectionLost = false; debugger.FinishRewriteSequence(); } StreamWriter emitWriter = impl.curShellProcEnv.ProcEnv.EmitWriter as StreamWriter; if (emitWriter != null) { emitWriter.Flush(); } }