The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.XsltOld \ VariableActionDbg

  1. //------------------------------------------------------------------------------
  2. // <copyright file="DbgCompiler.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Xml.Xsl.XsltOld
  16. {
  17.     using Res = System.Xml.Utils.Res;
  18.     using System;
  19.     using System.Collections;
  20.     using System.Xml;
  21.     using System.Xml.XPath;
  22.     using System.Xml.Xsl.XsltOld.Debugger;
  23.     using System.Diagnostics;
  24.    
  25.     internal class DbgData
  26.     {
  27.         private XPathNavigator styleSheet;
  28.         private VariableAction[] variables;
  29.         public XPathNavigator StyleSheet {
  30.             get { return this.styleSheet; }
  31.         }
  32.         public VariableAction[] Variables {
  33.             get { return this.variables; }
  34.         }
  35.         public DbgData(Compiler compiler)
  36.         {
  37.             DbgCompiler dbgCompiler = (DbgCompiler)compiler;
  38.             this.styleSheet = dbgCompiler.Input.Navigator.Clone();
  39.             this.variables = dbgCompiler.LocalVariables;
  40.             dbgCompiler.Debugger.OnInstructionCompile(this.StyleSheet);
  41.         }
  42.         internal void ReplaceVariables(VariableAction[] vars)
  43.         {
  44.             this.variables = vars;
  45.         }
  46.        
  47.         // static Empty:
  48.         private static DbgData s_nullDbgData = new DbgData();
  49.         private DbgData()
  50.         {
  51.             this.styleSheet = null;
  52.             this.variables = new VariableAction[0];
  53.         }
  54.         public static DbgData Empty {
  55.             get { return s_nullDbgData; }
  56.         }
  57.     }
  58.    
  59.     internal class DbgCompiler : Compiler
  60.     {
  61.         private IXsltDebugger debugger;
  62.        
  63.         public DbgCompiler(IXsltDebugger debugger)
  64.         {
  65.             this.debugger = debugger;
  66.         }
  67.         public override IXsltDebugger Debugger {
  68.             get { return this.debugger; }
  69.         }
  70.        
  71.         // Variables
  72.         //
  73.         // In XsltDebugger we have to know variables that are visible from each action.
  74.         // We keepping two different sets of wariables because global and local variables have different rules of visibility.
  75.         // Globals: All global variables are visible avryware (uncalucaled will have null value),
  76.         // Duplicated globals from different stilesheets are replaced (by import presidence)
  77.         // Locals: Visible only in scope and after it was defined.
  78.         // No duplicates posible.
  79.         private ArrayList globalVars = new ArrayList();
  80.         private ArrayList localVars = new ArrayList();
  81.         private VariableAction[] globalVarsCache, localVarsCache;
  82.        
  83.         public virtual VariableAction[] GlobalVariables {
  84.             get {
  85.                 Debug.Assert(this.Debugger != null);
  86.                 if (this.globalVarsCache == null) {
  87.                     this.globalVarsCache = (VariableAction[])this.globalVars.ToArray(typeof(VariableAction));
  88.                 }
  89.                 return this.globalVarsCache;
  90.             }
  91.         }
  92.         public virtual VariableAction[] LocalVariables {
  93.             get {
  94.                 Debug.Assert(this.Debugger != null);
  95.                 if (this.localVarsCache == null) {
  96.                     this.localVarsCache = (VariableAction[])this.localVars.ToArray(typeof(VariableAction));
  97.                 }
  98.                 return this.localVarsCache;
  99.             }
  100.         }
  101.        
  102.         private void DefineVariable(VariableAction variable)
  103.         {
  104.             Debug.Assert(this.Debugger != null);
  105.             if (variable.IsGlobal) {
  106.                 for (int i = 0; i < globalVars.Count; i++) {
  107.                     VariableAction oldVar = (VariableAction)this.globalVars[i];
  108.                     if (oldVar.Name == variable.Name) {
  109.                         // Duplicate var definition
  110.                         if (variable.Stylesheetid < oldVar.Stylesheetid) {
  111.                             Debug.Assert(variable.VarKey != -1, "Variable was already placed and it should replace prev var.");
  112.                             this.globalVars[i] = variable;
  113.                             this.globalVarsCache = null;
  114.                         }
  115.                         return;
  116.                     }
  117.                 }
  118.                 this.globalVars.Add(variable);
  119.                 this.globalVarsCache = null;
  120.             }
  121.             else {
  122.                 // local variables never conflict
  123.                 localVars.Add(variable);
  124.                 this.localVarsCache = null;
  125.             }
  126.         }
  127.        
  128.         private void UnDefineVariables(int count)
  129.         {
  130.             Debug.Assert(0 <= count, "This scope can't have more variables than we have in total");
  131.             Debug.Assert(count <= this.localVars.Count, "This scope can't have more variables than we have in total");
  132.             if (count != 0) {
  133.                 this.localVars.RemoveRange(this.localVars.Count - count, count);
  134.                 this.localVarsCache = null;
  135.             }
  136.         }
  137.        
  138.         internal override void PopScope()
  139.         {
  140.             this.UnDefineVariables(this.ScopeManager.CurrentScope.GetVeriablesCount());
  141.             base.PopScope();
  142.         }
  143.        
  144.         // ---------------- Actions: ---------------
  145.        
  146.         public override ApplyImportsAction CreateApplyImportsAction()
  147.         {
  148.             ApplyImportsAction action = new ApplyImportsActionDbg();
  149.             action.Compile(this);
  150.             return action;
  151.         }
  152.        
  153.         public override ApplyTemplatesAction CreateApplyTemplatesAction()
  154.         {
  155.             ApplyTemplatesAction action = new ApplyTemplatesActionDbg();
  156.             action.Compile(this);
  157.             return action;
  158.         }
  159.        
  160.         public override AttributeAction CreateAttributeAction()
  161.         {
  162.             AttributeAction action = new AttributeActionDbg();
  163.             action.Compile(this);
  164.             return action;
  165.         }
  166.        
  167.         public override AttributeSetAction CreateAttributeSetAction()
  168.         {
  169.             AttributeSetAction action = new AttributeSetActionDbg();
  170.             action.Compile(this);
  171.             return action;
  172.         }
  173.        
  174.         public override CallTemplateAction CreateCallTemplateAction()
  175.         {
  176.             CallTemplateAction action = new CallTemplateActionDbg();
  177.             action.Compile(this);
  178.             return action;
  179.         }
  180.        
  181.         public override ChooseAction CreateChooseAction()
  182.         {
  183.             //!!! don't need to be here
  184.             ChooseAction action = new ChooseAction();
  185.             action.Compile(this);
  186.             return action;
  187.         }
  188.        
  189.         public override CommentAction CreateCommentAction()
  190.         {
  191.             CommentAction action = new CommentActionDbg();
  192.             action.Compile(this);
  193.             return action;
  194.         }
  195.        
  196.         public override CopyAction CreateCopyAction()
  197.         {
  198.             CopyAction action = new CopyActionDbg();
  199.             action.Compile(this);
  200.             return action;
  201.         }
  202.        
  203.         public override CopyOfAction CreateCopyOfAction()
  204.         {
  205.             CopyOfAction action = new CopyOfActionDbg();
  206.             action.Compile(this);
  207.             return action;
  208.         }
  209.        
  210.         public override ElementAction CreateElementAction()
  211.         {
  212.             ElementAction action = new ElementActionDbg();
  213.             action.Compile(this);
  214.             return action;
  215.         }
  216.        
  217.         public override ForEachAction CreateForEachAction()
  218.         {
  219.             ForEachAction action = new ForEachActionDbg();
  220.             action.Compile(this);
  221.             return action;
  222.         }
  223.        
  224.         public override IfAction CreateIfAction(IfAction.ConditionType type)
  225.         {
  226.             IfAction action = new IfActionDbg(type);
  227.             action.Compile(this);
  228.             return action;
  229.         }
  230.        
  231.         public override MessageAction CreateMessageAction()
  232.         {
  233.             MessageAction action = new MessageActionDbg();
  234.             action.Compile(this);
  235.             return action;
  236.         }
  237.        
  238.         public override NewInstructionAction CreateNewInstructionAction()
  239.         {
  240.             NewInstructionAction action = new NewInstructionActionDbg();
  241.             action.Compile(this);
  242.             return action;
  243.         }
  244.        
  245.         public override NumberAction CreateNumberAction()
  246.         {
  247.             NumberAction action = new NumberActionDbg();
  248.             action.Compile(this);
  249.             return action;
  250.         }
  251.        
  252.         public override ProcessingInstructionAction CreateProcessingInstructionAction()
  253.         {
  254.             ProcessingInstructionAction action = new ProcessingInstructionActionDbg();
  255.             action.Compile(this);
  256.             return action;
  257.         }
  258.        
  259.         public override void CreateRootAction()
  260.         {
  261.             this.RootAction = new RootActionDbg();
  262.             this.RootAction.Compile(this);
  263.         }
  264.        
  265.         public override SortAction CreateSortAction()
  266.         {
  267.             SortAction action = new SortActionDbg();
  268.             action.Compile(this);
  269.             return action;
  270.         }
  271.        
  272.         public override TemplateAction CreateTemplateAction()
  273.         {
  274.             TemplateAction action = new TemplateActionDbg();
  275.             action.Compile(this);
  276.             return action;
  277.         }
  278.        
  279.         public override TemplateAction CreateSingleTemplateAction()
  280.         {
  281.             TemplateAction action = new TemplateActionDbg();
  282.             action.CompileSingle(this);
  283.             return action;
  284.         }
  285.        
  286.         public override TextAction CreateTextAction()
  287.         {
  288.             TextAction action = new TextActionDbg();
  289.             action.Compile(this);
  290.             return action;
  291.         }
  292.        
  293.         public override UseAttributeSetsAction CreateUseAttributeSetsAction()
  294.         {
  295.             UseAttributeSetsAction action = new UseAttributeSetsActionDbg();
  296.             action.Compile(this);
  297.             return action;
  298.         }
  299.        
  300.         public override ValueOfAction CreateValueOfAction()
  301.         {
  302.             ValueOfAction action = new ValueOfActionDbg();
  303.             action.Compile(this);
  304.             return action;
  305.         }
  306.        
  307.         public override VariableAction CreateVariableAction(VariableType type)
  308.         {
  309.             VariableAction action = new VariableActionDbg(type);
  310.             action.Compile(this);
  311.             return action;
  312.         }
  313.        
  314.         public override WithParamAction CreateWithParamAction()
  315.         {
  316.             WithParamAction action = new WithParamActionDbg();
  317.             action.Compile(this);
  318.             return action;
  319.         }
  320.        
  321.         // ---------------- Events: ---------------
  322.        
  323.         public override BeginEvent CreateBeginEvent()
  324.         {
  325.             return new BeginEventDbg(this);
  326.         }
  327.        
  328.         public override TextEvent CreateTextEvent()
  329.         {
  330.             return new TextEventDbg(this);
  331.         }
  332.        
  333.         // Debugger enabled implemetation of most compiled actions
  334.        
  335.         private class ApplyImportsActionDbg : ApplyImportsAction
  336.         {
  337.             private DbgData dbgData;
  338.             internal override DbgData GetDbgData(ActionFrame frame)
  339.             {
  340.                 return this.dbgData;
  341.             }
  342.            
  343.             internal override void Compile(Compiler compiler)
  344.             {
  345.                 dbgData = new DbgData(compiler);
  346.                 base.Compile(compiler);
  347.             }
  348.            
  349.             internal override void Execute(Processor processor, ActionFrame frame)
  350.             {
  351.                 if (frame.State == Initialized) {
  352.                     processor.OnInstructionExecute();
  353.                 }
  354.                 base.Execute(processor, frame);
  355.             }
  356.         }
  357.        
  358.         private class ApplyTemplatesActionDbg : ApplyTemplatesAction
  359.         {
  360.             private DbgData dbgData;
  361.             internal override DbgData GetDbgData(ActionFrame frame)
  362.             {
  363.                 return this.dbgData;
  364.             }
  365.            
  366.             internal override void Compile(Compiler compiler)
  367.             {
  368.                 dbgData = new DbgData(compiler);
  369.                 base.Compile(compiler);
  370.             }
  371.            
  372.             internal override void Execute(Processor processor, ActionFrame frame)
  373.             {
  374.                 if (frame.State == Initialized) {
  375.                     processor.OnInstructionExecute();
  376.                 }
  377.                 base.Execute(processor, frame);
  378.             }
  379.         }
  380.        
  381.         private class AttributeActionDbg : AttributeAction
  382.         {
  383.             private DbgData dbgData;
  384.             internal override DbgData GetDbgData(ActionFrame frame)
  385.             {
  386.                 return this.dbgData;
  387.             }
  388.            
  389.             internal override void Compile(Compiler compiler)
  390.             {
  391.                 dbgData = new DbgData(compiler);
  392.                 base.Compile(compiler);
  393.             }
  394.            
  395.             internal override void Execute(Processor processor, ActionFrame frame)
  396.             {
  397.                 if (frame.State == Initialized) {
  398.                     processor.OnInstructionExecute();
  399.                 }
  400.                 base.Execute(processor, frame);
  401.             }
  402.         }
  403.        
  404.         private class AttributeSetActionDbg : AttributeSetAction
  405.         {
  406.             private DbgData dbgData;
  407.             internal override DbgData GetDbgData(ActionFrame frame)
  408.             {
  409.                 return this.dbgData;
  410.             }
  411.            
  412.             internal override void Compile(Compiler compiler)
  413.             {
  414.                 dbgData = new DbgData(compiler);
  415.                 base.Compile(compiler);
  416.             }
  417.            
  418.             internal override void Execute(Processor processor, ActionFrame frame)
  419.             {
  420.                 if (frame.State == Initialized) {
  421.                     processor.OnInstructionExecute();
  422.                 }
  423.                 base.Execute(processor, frame);
  424.             }
  425.         }
  426.        
  427.         private class CallTemplateActionDbg : CallTemplateAction
  428.         {
  429.             private DbgData dbgData;
  430.             internal override DbgData GetDbgData(ActionFrame frame)
  431.             {
  432.                 return this.dbgData;
  433.             }
  434.            
  435.             internal override void Compile(Compiler compiler)
  436.             {
  437.                 dbgData = new DbgData(compiler);
  438.                 base.Compile(compiler);
  439.             }
  440.            
  441.             internal override void Execute(Processor processor, ActionFrame frame)
  442.             {
  443.                 if (frame.State == Initialized) {
  444.                     processor.OnInstructionExecute();
  445.                 }
  446.                 base.Execute(processor, frame);
  447.             }
  448.         }
  449.        
  450.         private class CommentActionDbg : CommentAction
  451.         {
  452.             private DbgData dbgData;
  453.             internal override DbgData GetDbgData(ActionFrame frame)
  454.             {
  455.                 return this.dbgData;
  456.             }
  457.            
  458.             internal override void Compile(Compiler compiler)
  459.             {
  460.                 dbgData = new DbgData(compiler);
  461.                 base.Compile(compiler);
  462.             }
  463.            
  464.             internal override void Execute(Processor processor, ActionFrame frame)
  465.             {
  466.                 if (frame.State == Initialized) {
  467.                     processor.OnInstructionExecute();
  468.                 }
  469.                 base.Execute(processor, frame);
  470.             }
  471.         }
  472.        
  473.         private class CopyActionDbg : CopyAction
  474.         {
  475.             private DbgData dbgData;
  476.             internal override DbgData GetDbgData(ActionFrame frame)
  477.             {
  478.                 return this.dbgData;
  479.             }
  480.            
  481.             internal override void Compile(Compiler compiler)
  482.             {
  483.                 dbgData = new DbgData(compiler);
  484.                 base.Compile(compiler);
  485.             }
  486.            
  487.             internal override void Execute(Processor processor, ActionFrame frame)
  488.             {
  489.                 if (frame.State == Initialized) {
  490.                     processor.OnInstructionExecute();
  491.                 }
  492.                 base.Execute(processor, frame);
  493.             }
  494.         }
  495.        
  496.         private class CopyOfActionDbg : CopyOfAction
  497.         {
  498.             private DbgData dbgData;
  499.             internal override DbgData GetDbgData(ActionFrame frame)
  500.             {
  501.                 return this.dbgData;
  502.             }
  503.            
  504.             internal override void Compile(Compiler compiler)
  505.             {
  506.                 dbgData = new DbgData(compiler);
  507.                 base.Compile(compiler);
  508.             }
  509.            
  510.             internal override void Execute(Processor processor, ActionFrame frame)
  511.             {
  512.                 if (frame.State == Initialized) {
  513.                     processor.OnInstructionExecute();
  514.                 }
  515.                 base.Execute(processor, frame);
  516.             }
  517.         }
  518.        
  519.         private class ElementActionDbg : ElementAction
  520.         {
  521.             private DbgData dbgData;
  522.             internal override DbgData GetDbgData(ActionFrame frame)
  523.             {
  524.                 return this.dbgData;
  525.             }
  526.            
  527.             internal override void Compile(Compiler compiler)
  528.             {
  529.                 dbgData = new DbgData(compiler);
  530.                 base.Compile(compiler);
  531.             }
  532.            
  533.             internal override void Execute(Processor processor, ActionFrame frame)
  534.             {
  535.                 if (frame.State == Initialized) {
  536.                     processor.OnInstructionExecute();
  537.                 }
  538.                 base.Execute(processor, frame);
  539.             }
  540.         }
  541.        
  542.         private class ForEachActionDbg : ForEachAction
  543.         {
  544.             private DbgData dbgData;
  545.             internal override DbgData GetDbgData(ActionFrame frame)
  546.             {
  547.                 return this.dbgData;
  548.             }
  549.            
  550.             internal override void Compile(Compiler compiler)
  551.             {
  552.                 dbgData = new DbgData(compiler);
  553.                 base.Compile(compiler);
  554.             }
  555.            
  556.             internal override void Execute(Processor processor, ActionFrame frame)
  557.             {
  558.                 if (frame.State == Initialized) {
  559.                     processor.PushDebuggerStack();
  560.                     processor.OnInstructionExecute();
  561.                 }
  562.                 base.Execute(processor, frame);
  563.                 if (frame.State == Finished) {
  564.                     processor.PopDebuggerStack();
  565.                 }
  566.             }
  567.         }
  568.        
  569.         private class IfActionDbg : IfAction
  570.         {
  571.             internal IfActionDbg(ConditionType type) : base(type)
  572.             {
  573.             }
  574.            
  575.             private DbgData dbgData;
  576.             internal override DbgData GetDbgData(ActionFrame frame)
  577.             {
  578.                 return this.dbgData;
  579.             }
  580.            
  581.             internal override void Compile(Compiler compiler)
  582.             {
  583.                 dbgData = new DbgData(compiler);
  584.                 base.Compile(compiler);
  585.             }
  586.            
  587.             internal override void Execute(Processor processor, ActionFrame frame)
  588.             {
  589.                 if (frame.State == Initialized) {
  590.                     processor.OnInstructionExecute();
  591.                 }
  592.                 base.Execute(processor, frame);
  593.             }
  594.         }
  595.        
  596.         private class MessageActionDbg : MessageAction
  597.         {
  598.             private DbgData dbgData;
  599.             internal override DbgData GetDbgData(ActionFrame frame)
  600.             {
  601.                 return this.dbgData;
  602.             }
  603.            
  604.             internal override void Compile(Compiler compiler)
  605.             {
  606.                 dbgData = new DbgData(compiler);
  607.                 base.Compile(compiler);
  608.             }
  609.            
  610.             internal override void Execute(Processor processor, ActionFrame frame)
  611.             {
  612.                 if (frame.State == Initialized) {
  613.                     processor.OnInstructionExecute();
  614.                 }
  615.                 base.Execute(processor, frame);
  616.             }
  617.         }
  618.        
  619.         private class NewInstructionActionDbg : NewInstructionAction
  620.         {
  621.             private DbgData dbgData;
  622.             internal override DbgData GetDbgData(ActionFrame frame)
  623.             {
  624.                 return this.dbgData;
  625.             }
  626.            
  627.             internal override void Compile(Compiler compiler)
  628.             {
  629.                 dbgData = new DbgData(compiler);
  630.                 base.Compile(compiler);
  631.             }
  632.            
  633.             internal override void Execute(Processor processor, ActionFrame frame)
  634.             {
  635.                 if (frame.State == Initialized) {
  636.                     processor.OnInstructionExecute();
  637.                 }
  638.                 base.Execute(processor, frame);
  639.             }
  640.         }
  641.        
  642.         private class NumberActionDbg : NumberAction
  643.         {
  644.             private DbgData dbgData;
  645.             internal override DbgData GetDbgData(ActionFrame frame)
  646.             {
  647.                 return this.dbgData;
  648.             }
  649.            
  650.             internal override void Compile(Compiler compiler)
  651.             {
  652.                 dbgData = new DbgData(compiler);
  653.                 base.Compile(compiler);
  654.             }
  655.            
  656.             internal override void Execute(Processor processor, ActionFrame frame)
  657.             {
  658.                 if (frame.State == Initialized) {
  659.                     processor.OnInstructionExecute();
  660.                 }
  661.                 base.Execute(processor, frame);
  662.             }
  663.         }
  664.        
  665.         private class ProcessingInstructionActionDbg : ProcessingInstructionAction
  666.         {
  667.             private DbgData dbgData;
  668.             internal override DbgData GetDbgData(ActionFrame frame)
  669.             {
  670.                 return this.dbgData;
  671.             }
  672.            
  673.             internal override void Compile(Compiler compiler)
  674.             {
  675.                 dbgData = new DbgData(compiler);
  676.                 base.Compile(compiler);
  677.             }
  678.            
  679.             internal override void Execute(Processor processor, ActionFrame frame)
  680.             {
  681.                 if (frame.State == Initialized) {
  682.                     processor.OnInstructionExecute();
  683.                 }
  684.                 base.Execute(processor, frame);
  685.             }
  686.         }
  687.        
  688.         private class RootActionDbg : RootAction
  689.         {
  690.             private DbgData dbgData;
  691.             internal override DbgData GetDbgData(ActionFrame frame)
  692.             {
  693.                 return this.dbgData;
  694.             }
  695.            
  696.             internal override void Compile(Compiler compiler)
  697.             {
  698.                 dbgData = new DbgData(compiler);
  699.                 base.Compile(compiler);
  700.                
  701.                 Debug.Assert(compiler.Debugger != null);
  702.                 string builtIn = compiler.Debugger.GetBuiltInTemplatesUri();
  703.                 if (builtIn != null && builtIn.Length != 0) {
  704.                     compiler.AllowBuiltInMode = true;
  705.                     builtInSheet = compiler.RootAction.CompileImport(compiler, compiler.ResolveUri(builtIn), int.MaxValue);
  706.                     compiler.AllowBuiltInMode = false;
  707.                 }
  708.                
  709.                 dbgData.ReplaceVariables(((DbgCompiler)compiler).GlobalVariables);
  710.             }
  711.            
  712.             internal override void Execute(Processor processor, ActionFrame frame)
  713.             {
  714.                 if (frame.State == Initialized) {
  715.                     processor.PushDebuggerStack();
  716.                     processor.OnInstructionExecute();
  717.                     processor.PushDebuggerStack();
  718.                 }
  719.                 base.Execute(processor, frame);
  720.                 if (frame.State == Finished) {
  721.                     processor.PopDebuggerStack();
  722.                     processor.PopDebuggerStack();
  723.                 }
  724.             }
  725.         }
  726.        
  727.         private class SortActionDbg : SortAction
  728.         {
  729.             private DbgData dbgData;
  730.             internal override DbgData GetDbgData(ActionFrame frame)
  731.             {
  732.                 return this.dbgData;
  733.             }
  734.            
  735.             internal override void Compile(Compiler compiler)
  736.             {
  737.                 dbgData = new DbgData(compiler);
  738.                 base.Compile(compiler);
  739.             }
  740.            
  741.             internal override void Execute(Processor processor, ActionFrame frame)
  742.             {
  743.                 if (frame.State == Initialized) {
  744.                     processor.OnInstructionExecute();
  745.                 }
  746.                 base.Execute(processor, frame);
  747.             }
  748.         }
  749.        
  750.         private class TemplateActionDbg : TemplateAction
  751.         {
  752.             private DbgData dbgData;
  753.             internal override DbgData GetDbgData(ActionFrame frame)
  754.             {
  755.                 return this.dbgData;
  756.             }
  757.            
  758.             internal override void Compile(Compiler compiler)
  759.             {
  760.                 dbgData = new DbgData(compiler);
  761.                 base.Compile(compiler);
  762.             }
  763.            
  764.             internal override void Execute(Processor processor, ActionFrame frame)
  765.             {
  766.                 if (frame.State == Initialized) {
  767.                     processor.PushDebuggerStack();
  768.                     processor.OnInstructionExecute();
  769.                 }
  770.                 base.Execute(processor, frame);
  771.                 if (frame.State == Finished) {
  772.                     processor.PopDebuggerStack();
  773.                 }
  774.             }
  775.         }
  776.        
  777.         private class TextActionDbg : TextAction
  778.         {
  779.             private DbgData dbgData;
  780.             internal override DbgData GetDbgData(ActionFrame frame)
  781.             {
  782.                 return this.dbgData;
  783.             }
  784.            
  785.             internal override void Compile(Compiler compiler)
  786.             {
  787.                 dbgData = new DbgData(compiler);
  788.                 base.Compile(compiler);
  789.             }
  790.            
  791.             internal override void Execute(Processor processor, ActionFrame frame)
  792.             {
  793.                 if (frame.State == Initialized) {
  794.                     processor.OnInstructionExecute();
  795.                 }
  796.                 base.Execute(processor, frame);
  797.             }
  798.         }
  799.        
  800.         private class UseAttributeSetsActionDbg : UseAttributeSetsAction
  801.         {
  802.             private DbgData dbgData;
  803.             internal override DbgData GetDbgData(ActionFrame frame)
  804.             {
  805.                 return this.dbgData;
  806.             }
  807.            
  808.             internal override void Compile(Compiler compiler)
  809.             {
  810.                 dbgData = new DbgData(compiler);
  811.                 base.Compile(compiler);
  812.             }
  813.            
  814.             internal override void Execute(Processor processor, ActionFrame frame)
  815.             {
  816.                 if (frame.State == Initialized) {
  817.                     processor.OnInstructionExecute();
  818.                 }
  819.                 base.Execute(processor, frame);
  820.             }
  821.         }
  822.        
  823.         private class ValueOfActionDbg : ValueOfAction
  824.         {
  825.             private DbgData dbgData;
  826.             internal override DbgData GetDbgData(ActionFrame frame)
  827.             {
  828.                 return this.dbgData;
  829.             }
  830.            
  831.             internal override void Compile(Compiler compiler)
  832.             {
  833.                 dbgData = new DbgData(compiler);
  834.                 base.Compile(compiler);
  835.             }
  836.            
  837.             internal override void Execute(Processor processor, ActionFrame frame)
  838.             {
  839.                 if (frame.State == Initialized) {
  840.                     processor.OnInstructionExecute();
  841.                 }
  842.                 base.Execute(processor, frame);
  843.             }
  844.         }
  845.        
  846.         private class VariableActionDbg : VariableAction
  847.         {
  848.             internal VariableActionDbg(VariableType type) : base(type)
  849.             {
  850.             }
  851.             private DbgData dbgData;
  852.             internal override DbgData GetDbgData(ActionFrame frame)
  853.             {
  854.                 return this.dbgData;
  855.             }
  856.            
  857.             internal override void Compile(Compiler compiler)
  858.             {
  859.                 dbgData = new DbgData(compiler);
  860.                 base.Compile(compiler);
  861.                 ((DbgCompiler)compiler).DefineVariable(this);
  862.             }
  863.            
  864.             internal override void Execute(Processor processor, ActionFrame frame)
  865.             {
  866.                 if (frame.State == Initialized) {
  867.                     processor.OnInstructionExecute();
  868.                 }
  869.                 base.Execute(processor, frame);
  870.             }
  871.         }
  872.        
  873.         private class WithParamActionDbg : WithParamAction
  874.         {
  875.             private DbgData dbgData;
  876.             internal override DbgData GetDbgData(ActionFrame frame)
  877.             {
  878.                 return this.dbgData;
  879.             }
  880.            
  881.             internal override void Compile(Compiler compiler)
  882.             {
  883.                 dbgData = new DbgData(compiler);
  884.                 base.Compile(compiler);
  885.             }
  886.            
  887.             internal override void Execute(Processor processor, ActionFrame frame)
  888.             {
  889.                 if (frame.State == Initialized) {
  890.                     processor.OnInstructionExecute();
  891.                 }
  892.                 base.Execute(processor, frame);
  893.             }
  894.         }
  895.        
  896.         // ---------------- Events: ---------------
  897.        
  898.         private class BeginEventDbg : BeginEvent
  899.         {
  900.             private DbgData dbgData;
  901.             internal override DbgData DbgData {
  902.                 get { return this.dbgData; }
  903.             }
  904.            
  905.             public BeginEventDbg(Compiler compiler) : base(compiler)
  906.             {
  907.                 dbgData = new DbgData(compiler);
  908.             }
  909.             public override bool Output(Processor processor, ActionFrame frame)
  910.             {
  911.                 this.OnInstructionExecute(processor);
  912.                 return base.Output(processor, frame);
  913.             }
  914.         }
  915.        
  916.         private class TextEventDbg : TextEvent
  917.         {
  918.             private DbgData dbgData;
  919.             internal override DbgData DbgData {
  920.                 get { return this.dbgData; }
  921.             }
  922.            
  923.             public TextEventDbg(Compiler compiler) : base(compiler)
  924.             {
  925.                 dbgData = new DbgData(compiler);
  926.             }
  927.             public override bool Output(Processor processor, ActionFrame frame)
  928.             {
  929.                 this.OnInstructionExecute(processor);
  930.                 return base.Output(processor, frame);
  931.             }
  932.         }
  933.     }
  934. }

Developer Fusion