DbgCompiler.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / XmlUtils / System / Xml / Xsl / XsltOld / DbgCompiler.cs / 1305376 / DbgCompiler.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Xsl.XsltOld { 
    using Res = System.Xml.Utils.Res;
    using System; 
    using System.Collections;
    using System.Xml;
    using System.Xml.XPath;
    using System.Xml.Xsl.XsltOld.Debugger; 
    using System.Diagnostics;
    using System.Runtime.Versioning; 
 
    internal class DbgData {
        private XPathNavigator   styleSheet; 
        private VariableAction[] variables;
        public XPathNavigator   StyleSheet { get { return this.styleSheet; } }
        public VariableAction[] Variables  { get { return this.variables;  } }
        public DbgData(Compiler compiler) { 
            DbgCompiler dbgCompiler = (DbgCompiler) compiler;
            this.styleSheet = dbgCompiler.Input.Navigator.Clone(); 
            this.variables  = dbgCompiler.LocalVariables; 
            dbgCompiler.Debugger.OnInstructionCompile(this.StyleSheet);
        } 
        internal void ReplaceVariables(VariableAction[] vars) { this.variables = vars; }

        // static Empty:
        private static DbgData s_nullDbgData = new DbgData(); 
        private DbgData() {
            this.styleSheet = null; 
            this.variables  = new VariableAction[0]; 
        }
        public static DbgData Empty { get { return s_nullDbgData; } } 
    }

    internal class DbgCompiler : Compiler {
        private IXsltDebugger debugger; 

        public DbgCompiler(IXsltDebugger debugger) { 
            this.debugger = debugger; 
        }
        public override IXsltDebugger Debugger { get { return this.debugger; } } 

        // Variables
        //
        // In XsltDebugger we have to know variables that are visible from each action. 
        // We keepping two different sets of wariables because global and local variables have different rules of visibility.
        // Globals: All global variables are visible avryware (uncalucaled will have null value), 
        //          Duplicated globals from different stilesheets are replaced (by import presidence) 
        // Locals:  Visible only in scope and after it was defined.
        //          No duplicates posible. 
        private ArrayList        globalVars = new ArrayList();
        private ArrayList        localVars  = new ArrayList();
        private VariableAction[] globalVarsCache, localVarsCache;
 
        public virtual VariableAction[] GlobalVariables {
            get { 
                Debug.Assert(this.Debugger != null); 
                if (this.globalVarsCache == null) {
                    this.globalVarsCache = (VariableAction[]) this.globalVars.ToArray(typeof(VariableAction)); 
                }
                return this.globalVarsCache;
            }
        } 
        public virtual VariableAction[] LocalVariables {
            get { 
                Debug.Assert(this.Debugger != null); 
                if (this.localVarsCache == null) {
                    this.localVarsCache = (VariableAction[]) this.localVars.ToArray(typeof(VariableAction)); 
                }
                return this.localVarsCache;
            }
        } 

        private void DefineVariable(VariableAction variable) { 
            Debug.Assert(this.Debugger != null); 
            if (variable.IsGlobal) {
                for(int i = 0; i < globalVars.Count; i ++) { 
                    VariableAction oldVar = (VariableAction)this.globalVars[i];
                    if(oldVar.Name == variable.Name) { // Duplicate var definition
                        if(variable.Stylesheetid < oldVar.Stylesheetid) {
                            Debug.Assert(variable.VarKey != -1, "Variable was already placed and it should replace prev var."); 
                            this.globalVars[i] = variable;
                            this.globalVarsCache = null; 
                        } 
                        return;
                    } 
                }
                this.globalVars.Add(variable);
                this.globalVarsCache = null;
            } 
            else {
                // local variables never conflict 
                localVars.Add(variable); 
                this.localVarsCache = null;
            } 
        }

        private void UnDefineVariables(int count) {
            Debug.Assert(0 <= count, "This scope can't have more variables than we have in total"); 
            Debug.Assert(count <= this.localVars.Count, "This scope can't have more variables than we have in total");
            if(count != 0) { 
                this.localVars.RemoveRange(this.localVars.Count - count, count); 
                this.localVarsCache = null;
            } 
        }

        internal override void PopScope() {
            this.UnDefineVariables(this.ScopeManager.CurrentScope.GetVeriablesCount()); 
            base.PopScope();
        } 
 
        // ---------------- Actions: ---------------
 
        public override ApplyImportsAction CreateApplyImportsAction() {
            ApplyImportsAction action = new ApplyImportsActionDbg();
            action.Compile(this);
            return action; 
        }
 
        public override ApplyTemplatesAction CreateApplyTemplatesAction() { 
            ApplyTemplatesAction action = new ApplyTemplatesActionDbg();
            action.Compile(this); 
            return action;
        }

        public override AttributeAction CreateAttributeAction() { 
            AttributeAction action = new AttributeActionDbg();
            action.Compile(this); 
            return action; 
        }
 
        public override AttributeSetAction CreateAttributeSetAction() {
            AttributeSetAction action = new AttributeSetActionDbg();
            action.Compile(this);
            return action; 
        }
 
        public override CallTemplateAction CreateCallTemplateAction() { 
            CallTemplateAction action = new CallTemplateActionDbg();
            action.Compile(this); 
            return action;
        }

        public override ChooseAction CreateChooseAction() {//!!! don't need to be here 
            ChooseAction action = new ChooseAction();
            action.Compile(this); 
            return action; 
        }
 
        public override CommentAction CreateCommentAction() {
            CommentAction action = new CommentActionDbg();
            action.Compile(this);
            return action; 
        }
 
        public override CopyAction CreateCopyAction() { 
            CopyAction action = new CopyActionDbg();
            action.Compile(this); 
            return action;
        }

        public override CopyOfAction CreateCopyOfAction() { 
            CopyOfAction action = new CopyOfActionDbg();
            action.Compile(this); 
            return action; 
        }
 
        public override ElementAction CreateElementAction() {
            ElementAction action = new ElementActionDbg();
            action.Compile(this);
            return action; 
        }
 
        public override ForEachAction CreateForEachAction() { 
            ForEachAction action = new ForEachActionDbg();
            action.Compile(this); 
            return action;
        }

        public override IfAction CreateIfAction(IfAction.ConditionType type) { 
            IfAction action = new IfActionDbg(type);
            action.Compile(this); 
            return action; 
        }
 
        public override MessageAction CreateMessageAction() {
            MessageAction action = new MessageActionDbg();
            action.Compile(this);
            return action; 
        }
 
        public override NewInstructionAction CreateNewInstructionAction() { 
            NewInstructionAction action = new NewInstructionActionDbg();
            action.Compile(this); 
            return action;
        }

        public override NumberAction CreateNumberAction() { 
            NumberAction action = new NumberActionDbg();
            action.Compile(this); 
            return action; 
        }
 
        public override ProcessingInstructionAction CreateProcessingInstructionAction() {
            ProcessingInstructionAction action = new ProcessingInstructionActionDbg();
            action.Compile(this);
            return action; 
        }
 
        public override void CreateRootAction() { 
            this.RootAction = new RootActionDbg();
            this.RootAction.Compile(this); 
        }

        public override SortAction CreateSortAction() {
            SortAction action = new SortActionDbg(); 
            action.Compile(this);
            return action; 
        } 

        public override TemplateAction CreateTemplateAction() { 
            TemplateAction action = new TemplateActionDbg();
            action.Compile(this);
            return action;
        } 

        public override TemplateAction CreateSingleTemplateAction() { 
            TemplateAction action = new TemplateActionDbg(); 
            action.CompileSingle(this);
            return action; 
        }

        public override TextAction CreateTextAction() {
            TextAction action = new TextActionDbg(); 
            action.Compile(this);
            return action; 
        } 

        public override UseAttributeSetsAction CreateUseAttributeSetsAction() { 
            UseAttributeSetsAction action = new UseAttributeSetsActionDbg();
            action.Compile(this);
            return action;
        } 

        public override ValueOfAction CreateValueOfAction() { 
            ValueOfAction action = new ValueOfActionDbg(); 
            action.Compile(this);
            return action; 
        }

        public override VariableAction CreateVariableAction(VariableType type) {
            VariableAction action = new VariableActionDbg(type); 
            action.Compile(this);
            return action; 
        } 

        public override WithParamAction CreateWithParamAction() { 
            WithParamAction action = new WithParamActionDbg();
            action.Compile(this);
            return action;
        } 

        // ---------------- Events: --------------- 
 
        public override BeginEvent CreateBeginEvent() {
            return new BeginEventDbg(this); 
        }

        public override TextEvent CreateTextEvent() {
            return new TextEventDbg(this); 
        }
 
        // Debugger enabled implemetation of most compiled actions 

        private class ApplyImportsActionDbg : ApplyImportsAction { 
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler); 
            } 

            internal override void Execute(Processor processor, ActionFrame frame) { 
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute();
                }
                base.Execute(processor, frame); 
            }
        } 
 
        private class ApplyTemplatesActionDbg : ApplyTemplatesAction {
            private DbgData dbgData; 
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }

            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler);
            } 
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) { 
                    processor.OnInstructionExecute();
                }
                base.Execute(processor, frame);
            } 
        }
 
        private class AttributeActionDbg : AttributeAction { 
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 

            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler);
                base.Compile(compiler); 
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) { 
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute(); 
                }
                base.Execute(processor, frame);
            }
        } 

        private class AttributeSetActionDbg : AttributeSetAction { 
            private DbgData dbgData; 
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler);
                base.Compile(compiler);
            } 

            internal override void Execute(Processor processor, ActionFrame frame) { 
                if(frame.State == Initialized) { 
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
            }
        }
 
        private class CallTemplateActionDbg : CallTemplateAction {
            private DbgData dbgData; 
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler);
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) { 
                    processor.OnInstructionExecute(); 
                }
                base.Execute(processor, frame); 
            }
        }

        private class CommentActionDbg : CommentAction { 
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler);
            }

            internal override void Execute(Processor processor, ActionFrame frame) { 
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute(); 
                } 
                base.Execute(processor, frame);
            } 
        }

        private class CopyActionDbg : CopyAction {
            private DbgData dbgData; 
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler); 
            }

            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) { 
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame); 
            }
        } 

        private class CopyOfActionDbg : CopyOfAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler); 
                base.Compile(compiler);
            } 

            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute(); 
                }
                base.Execute(processor, frame); 
            } 
        }
 
        private class ElementActionDbg : ElementAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler); 
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
            } 
        } 

        private class ForEachActionDbg : ForEachAction { 
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler); 
            } 

            internal override void Execute(Processor processor, ActionFrame frame) { 
                if(frame.State == Initialized) {
                    processor.PushDebuggerStack();
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
                if (frame.State == Finished) { 
                    processor.PopDebuggerStack(); 
                }
            } 
        }

        private class IfActionDbg : IfAction {
            internal IfActionDbg(ConditionType type) : base(type) {} 

            private DbgData dbgData; 
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler);
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) { 
                    processor.OnInstructionExecute(); 
                }
                base.Execute(processor, frame); 
            }
        }

        private class MessageActionDbg : MessageAction { 
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler);
            }

            internal override void Execute(Processor processor, ActionFrame frame) { 
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute(); 
                } 
                base.Execute(processor, frame);
            } 
        }

        private class NewInstructionActionDbg : NewInstructionAction {
            private DbgData dbgData; 
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler); 
            }

            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) { 
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame); 
            }
        } 

        private class NumberActionDbg : NumberAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler); 
                base.Compile(compiler);
            } 

            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute(); 
                }
                base.Execute(processor, frame); 
            } 
        }
 
        private class ProcessingInstructionActionDbg : ProcessingInstructionAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler); 
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
            } 
        } 

        private class RootActionDbg : RootAction { 
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }

            // SxS: This method does not take any resource name and does not expose any resources to the caller. 
            // It's OK to suppress the SxS warning.
            [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] 
            [ResourceExposure(ResourceScope.None)] 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler);

                Debug.Assert(compiler.Debugger != null);
                string builtIn = compiler.Debugger.GetBuiltInTemplatesUri(); 
                if (builtIn != null && builtIn.Length != 0) {
                    compiler.AllowBuiltInMode = true; 
                    builtInSheet = compiler.RootAction.CompileImport(compiler, compiler.ResolveUri(builtIn), int.MaxValue); 
                    compiler.AllowBuiltInMode = false;
                } 

                dbgData.ReplaceVariables(((DbgCompiler) compiler).GlobalVariables) ;
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if (frame.State == Initialized) { 
                    processor.PushDebuggerStack(); 
                    processor.OnInstructionExecute();
                    processor.PushDebuggerStack(); 
                }
                base.Execute(processor, frame);
                if (frame.State == Finished) {
                    processor.PopDebuggerStack(); 
                    processor.PopDebuggerStack();
                } 
            } 
        }
 
        private class SortActionDbg : SortAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler); 
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
            } 
        } 

        private class TemplateActionDbg : TemplateAction { 
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler); 
            } 

            internal override void Execute(Processor processor, ActionFrame frame) { 
                if(frame.State == Initialized) {
                    processor.PushDebuggerStack();
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
                if (frame.State == Finished) { 
                    processor.PopDebuggerStack(); 
                }
            } 
        }

        private class TextActionDbg : TextAction {
            private DbgData dbgData; 
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler);
                base.Compile(compiler); 
            }

            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) { 
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame); 
            }
        } 

        private class UseAttributeSetsActionDbg : UseAttributeSetsAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; } 

            internal override void Compile(Compiler compiler) { 
                dbgData = new DbgData(compiler); 
                base.Compile(compiler);
            } 

            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute(); 
                }
                base.Execute(processor, frame); 
            } 
        }
 
        private class ValueOfActionDbg : ValueOfAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler); 
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
            } 
        } 

        private class VariableActionDbg : VariableAction { 
            internal VariableActionDbg(VariableType type) : base(type) {}
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler); 
                ((DbgCompiler) compiler).DefineVariable(this);
            } 

            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute(); 
                }
                base.Execute(processor, frame); 
            } 
        }
 
        private class WithParamActionDbg : WithParamAction {
            private DbgData dbgData;
            internal override DbgData GetDbgData(ActionFrame frame) { return this.dbgData; }
 
            internal override void Compile(Compiler compiler) {
                dbgData = new DbgData(compiler); 
                base.Compile(compiler); 
            }
 
            internal override void Execute(Processor processor, ActionFrame frame) {
                if(frame.State == Initialized) {
                    processor.OnInstructionExecute();
                } 
                base.Execute(processor, frame);
            } 
        } 

        // ---------------- Events: --------------- 

        private class BeginEventDbg : BeginEvent {
            private DbgData dbgData;
            internal override DbgData DbgData { get { return this.dbgData; } } 

            public BeginEventDbg(Compiler compiler) : base(compiler) { 
                dbgData = new DbgData(compiler); 
            }
            public override bool Output(Processor processor, ActionFrame frame) { 
                this.OnInstructionExecute(processor);
                return base.Output(processor, frame);
            }
        } 

        private class TextEventDbg : TextEvent { 
            private DbgData dbgData; 
            internal override DbgData DbgData { get { return this.dbgData; } }
 
            public TextEventDbg(Compiler compiler) : base(compiler) {
                dbgData = new DbgData(compiler);
            }
            public override bool Output(Processor processor, ActionFrame frame) { 
                this.OnInstructionExecute(processor);
                return base.Output(processor, frame); 
            } 
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK