/// <summary>
/// This function is called on every recompilation to discard all previous results
/// </summary>
private void Reset()
{
_compilerErrorColl = null;
_outputSettings = null;
_qil = null;
_command = null;
}
//-----------------------------------------------
// Entry
//-----------------------------------------------
/// <summary>
/// Visits the specified QilExpression graph and generates MSIL code.
/// </summary>
public void Visit(QilExpression qil, GenerateHelper helper, MethodInfo methRoot)
{
_qil = qil;
_helper = helper;
_iterNested = null;
_indexId = 0;
// Prepare each global parameter and global variable to be visited
PrepareGlobalValues(qil.GlobalParameterList);
PrepareGlobalValues(qil.GlobalVariableList);
// Visit each global parameter and global variable
VisitGlobalValues(qil.GlobalParameterList);
VisitGlobalValues(qil.GlobalVariableList);
// Build each function
foreach (QilFunction ndFunc in qil.FunctionList)
{
// Visit each parameter and the function body
Function(ndFunc);
}
// Build the root expression
_helper.MethodBegin(methRoot, null, true);
StartNestedIterator(qil.Root);
Visit(qil.Root);
Debug.Assert(_iterCurr.Storage.Location == ItemLocation.None, "Root expression should have been pushed to the writer.");
EndNestedIterator(qil.Root);
_helper.MethodEnd();
}
/// <summary>
/// This function is called on every recompilation to discard all previous results
/// </summary>
private void Reset()
{
_compilerResults = null;
_outputSettings = null;
_qil = null;
_command = null;
}
public XmlILOptimizerVisitor(QilExpression qil, bool optimize) : base(optimize ? s_patternsOpt : s_patternsNoOpt, qil.Factory)
{
_qil = qil;
_elemAnalyzer = new XmlILElementAnalyzer(qil.Factory);
_contentAnalyzer = new XmlILStateAnalyzer(qil.Factory);
_nmspAnalyzer = new XmlILNamespaceAnalyzer();
}
//-----------------------------------------------
// Convenience methods
//-----------------------------------------------
public QilExpression QilExpression(QilNode root, QilFactory factory)
{
QilExpression n = new QilExpression(QilNodeType.QilExpression, root, factory);
n.XmlType = _typeCheck.CheckQilExpression(n);
TraceNode(n);
return n;
}
/// <summary>
/// Scan through the external parameters, global variables, and function list for forward references.
/// </summary>
protected override QilNode VisitQilExpression(QilExpression qil)
{
IList <QilNode> fdecls = new ForwardRefFinder().Find(qil);
if (fdecls != null && fdecls.Count > 0)
{
this.writer.WriteStartElement("ForwardDecls");
foreach (QilNode n in fdecls)
{
// i.e. <Function id="$a"/>
this.writer.WriteStartElement(Enum.GetName(typeof(QilNodeType), n.NodeType));
this.writer.WriteAttributeString("id", _ngen.NameOf(n));
WriteXmlType(n);
if (n.NodeType == QilNodeType.Function)
{
// Visit Arguments and SideEffects operands
Visit(n[0]);
Visit(n[2]);
}
this.writer.WriteEndElement();
}
this.writer.WriteEndElement();
}
return(VisitChildren(qil));
}
//-----------------------------------------------
// meta
//-----------------------------------------------
public QilExpression QilExpression(QilNode root)
{
QilExpression n = new QilExpression(QilNodeType.QilExpression, root);
n.XmlType = _typeCheck.CheckQilExpression(n);
TraceNode(n);
return(n);
}
/// <summary>
/// Perform tail-call analysis on the functions in the specified QilExpression.
/// </summary>
public static void Analyze(QilExpression qil) {
foreach (QilFunction ndFunc in qil.FunctionList) {
// Only analyze functions which are pushed to the writer, since otherwise code
// is generated after the call instruction in order to process cached results
if (XmlILConstructInfo.Read(ndFunc).ConstructMethod == XmlILConstructMethod.Writer)
AnalyzeDefinition(ndFunc.Definition);
}
}
//-----------------------------------------------
// Convenience methods
//-----------------------------------------------
public QilExpression QilExpression(QilNode root, QilFactory factory)
{
QilExpression n = new QilExpression(QilNodeType.QilExpression, root, factory);
n.XmlType = this.typeCheck.CheckQilExpression(n);
TraceNode(n);
return(n);
}
//-----------------------------------------------
// meta
//-----------------------------------------------
public XmlQueryType CheckQilExpression(QilExpression node)
{
Check(node[0].NodeType == QilNodeType.False || node[0].NodeType == QilNodeType.True, node, "IsDebug must either be True or False");
CheckLiteralValue(node[1], typeof(XmlWriterSettings));
CheckLiteralValue(node[2], typeof(IList <WhitespaceRule>));
CheckClassAndNodeType(node[3], typeof(QilList), QilNodeType.GlobalParameterList);
CheckClassAndNodeType(node[4], typeof(QilList), QilNodeType.GlobalVariableList);
CheckClassAndNodeType(node[5], typeof(QilList), QilNodeType.FunctionList);
return(XmlQueryTypeFactory.ItemS);
}
/// <summary>
/// Given the logical query plan (QilExpression) generate a physical query plan (MSIL) that can be executed.
/// </summary>
// SxS Note: The way the trace file names are created (hardcoded) is NOT SxS safe. However the files are
// created only for internal tracing purposes. In addition XmlILTrace class is not compiled into retail
// builds. As a result it is fine to suppress the FxCop SxS warning.
public XmlILCommand Generate(QilExpression query, TypeBuilder typeBldr)
{
_qil = query;
bool useLRE = (
!_qil.IsDebug &&
(typeBldr == null)
#if DEBUG
&& !XmlILTrace.IsEnabled // Dump assembly to disk; can't do this when using LRE
#endif
);
bool emitSymbols = _qil.IsDebug;
// In debug code, ensure that input QIL is correct
QilValidationVisitor.Validate(_qil);
#if DEBUG
// Trace Qil before optimization
XmlILTrace.WriteQil(this.qil, "qilbefore.xml");
// Trace optimizations
XmlILTrace.TraceOptimizations(this.qil, "qilopt.xml");
#endif
// Optimize and annotate the Qil graph
_optVisitor = new XmlILOptimizerVisitor(_qil, !_qil.IsDebug);
_qil = _optVisitor.Optimize();
// In debug code, ensure that output QIL is correct
QilValidationVisitor.Validate(_qil);
#if DEBUG
// Trace Qil after optimization
XmlILTrace.WriteQil(this.qil, "qilafter.xml");
#endif
// Create module in which methods will be generated
if (typeBldr != null)
{
_module = new XmlILModule(typeBldr);
}
else
{
_module = new XmlILModule(useLRE, emitSymbols);
}
// Create a code generation helper for the module; enable optimizations if IsDebug is false
_helper = new GenerateHelper(_module, _qil.IsDebug);
// Create helper methods
CreateHelperFunctions();
// Create metadata for the Execute function, which is the entry point to the query
// public static void Execute(XmlQueryRuntime);
MethodInfo methExec = _module.DefineMethod("Execute", typeof(void), new Type[] { }, new string[] { }, XmlILMethodAttributes.NonUser);
// Create metadata for the root expression
// public void Root()
Debug.Assert(_qil.Root != null);
XmlILMethodAttributes methAttrs = (_qil.Root.SourceLine == null) ? XmlILMethodAttributes.NonUser : XmlILMethodAttributes.None;
MethodInfo methRoot = _module.DefineMethod("Root", typeof(void), new Type[] { }, new string[] { }, methAttrs);
// Declare all early bound function objects
foreach (EarlyBoundInfo info in _qil.EarlyBoundTypes)
{
_helper.StaticData.DeclareEarlyBound(info.NamespaceUri, info.EarlyBoundType);
}
// Create metadata for each QilExpression function that has at least one caller
CreateFunctionMetadata(_qil.FunctionList);
// Create metadata for each QilExpression global variable and parameter
CreateGlobalValueMetadata(_qil.GlobalVariableList);
CreateGlobalValueMetadata(_qil.GlobalParameterList);
// Generate Execute method
GenerateExecuteFunction(methExec, methRoot);
// Visit the QilExpression graph
_xmlIlVisitor = new XmlILVisitor();
_xmlIlVisitor.Visit(_qil, _helper, methRoot);
// Collect all static information required by the runtime
XmlQueryStaticData staticData = new XmlQueryStaticData(
_qil.DefaultWriterSettings,
_qil.WhitespaceRules,
_helper.StaticData
);
// Create static constructor that initializes XmlQueryStaticData instance at runtime
if (typeBldr != null)
{
CreateTypeInitializer(staticData);
// Finish up creation of the type
_module.BakeMethods();
return null;
}
else
{
// Finish up creation of the type
_module.BakeMethods();
// Create delegate over "Execute" method
ExecuteDelegate delExec = (ExecuteDelegate)_module.CreateDelegate("Execute", typeof(ExecuteDelegate));
return new XmlILCommand(delExec, staticData);
}
}
// Do not edit this region
#region AUTOGENERATED
#region meta
protected override QilNode VisitQilExpression(QilExpression n) { return NoReplace(n); }
//-----------------------------------------------
// meta
//-----------------------------------------------
public QilExpression QilExpression(QilNode root) {
QilExpression n = new QilExpression(QilNodeType.QilExpression, root);
n.XmlType = this.typeCheck.CheckQilExpression(n);
TraceNode(n);
return n;
}
protected virtual QilNode VisitQilExpression(QilExpression n) { return VisitChildren(n); }
/// <summary>
/// Serialize rewritten Qil tree to writer "w".
/// </summary>
private static void WriteQilRewrite(QilExpression qil, XmlWriter w, string rewriteName) {
w.WriteStartElement("Diff");
if (rewriteName != null)
w.WriteAttributeString("rewrite", rewriteName);
WriteQil(qil, w);
w.WriteEndElement();
}
public XmlILOptimizerVisitor(QilExpression qil, bool optimize) : base(optimize ? PatternsOpt : PatternsNoOpt, qil.Factory) {
this.qil = qil;
this.elemAnalyzer = new XmlILElementAnalyzer(qil.Factory);
this.contentAnalyzer = new XmlILStateAnalyzer(qil.Factory);
this.nmspAnalyzer = new XmlILNamespaceAnalyzer();
}
// Do not edit this region
// It is auto-generated
#region AUTOGENERATED
#region meta
protected override QilNode VisitQilExpression(QilExpression local0) {
QilNode local1 = local0[0];
if (this[XmlILOptimization.EliminateUnusedFunctions]) {
if (AllowReplace(XmlILOptimization.EliminateUnusedFunctions, local0)) {
IList<QilNode> funcList = local0.FunctionList;
for (int i = funcList.Count - 1; i >= 0; i--) {
if (XmlILConstructInfo.Write(funcList[i]).CallersInfo.Count == 0)
funcList.RemoveAt(i);
}
}
}
if (this[XmlILOptimization.AnnotateConstruction]) {
if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0)) {
foreach (QilFunction ndFunc in local0.FunctionList) {
// Functions that construct Xml trees should stream output to writer; otherwise, results should
// be cached and returned.
if (IsConstructedExpression(ndFunc.Definition)) {
// Perform state analysis on function's content
ndFunc.Definition = this.contentAnalyzer.Analyze(ndFunc, ndFunc.Definition);
}
}
// Perform state analysis on the root expression
local0.Root = this.contentAnalyzer.Analyze(null, local0.Root);
// Make sure that root expression is pushed to writer
XmlILConstructInfo.Write(local0.Root).PushToWriterLast = true;
}
}
return NoReplace(local0);
}
/// <summary>
/// Given the logical query plan (QilExpression) generate a physical query plan (MSIL) that can be executed.
/// </summary>
public XmlCommand Generate(QilExpression query, AssemblyName asmName) {
MethodInfo methRoot, methExec;
bool useLRE, emitSymbols;
ExecuteDelegate delExec;
XmlILMethodAttributes methAttrs;
this.qil = query;
useLRE = !this.qil.IsDebug && (asmName == null);
emitSymbols = this.qil.IsDebug;
// In debug code, ensure that input QIL is correct
QilValidationVisitor.Validate(this.qil);
// Trace Qil before optimization
XmlILTrace.WriteQil(this.qil, "qilbefore.xml");
// Trace optimizations
XmlILTrace.TraceOptimizations(this.qil, "qilopt.xml");
if (XmlILTrace.IsEnabled) {
// Dump assembly to disk; can't do this when using LRE
useLRE = false;
}
// Optimize and annotate the Qil graph
this.optVisitor = new XmlILOptimizerVisitor(this.qil, !this.qil.IsDebug);
this.qil = this.optVisitor.Optimize();
// In debug code, ensure that output QIL is correct
QilValidationVisitor.Validate(this.qil);
// Trace Qil after optimization
XmlILTrace.WriteQil(this.qil, "qilafter.xml");
// Create module in which methods will be generated
this.module = new XmlILModule(useLRE, emitSymbols, asmName);
// Create a code generation helper for the module; enable optimizations if IsDebug is false
this.helper = new GenerateHelper(this.module, this.qil.IsDebug);
// Create helper methods
CreateHelperFunctions();
// Create metadata for the root expression
// public void Root()
Debug.Assert(this.qil.Root != null);
methAttrs = (this.qil.Root.SourceLine == null) ? XmlILMethodAttributes.NonUser : XmlILMethodAttributes.None;
methRoot = this.module.DefineMethod("Root", typeof(void), new Type[] {}, new string[] {}, methAttrs);
// Create metadata for each QilExpression function that has at least one caller
CreateFunctionMetadata(this.qil.FunctionList);
// Create metadata for each QilExpression global variable and parameter
CreateGlobalValueMetadata(this.qil.GlobalVariableList);
CreateGlobalValueMetadata(this.qil.GlobalParameterList);
// Create Execute method
methExec = CreateExecuteFunction(methRoot);
// Visit the QilExpression graph
this.xmlIlVisitor = new XmlILVisitor();
this.xmlIlVisitor.Visit(this.qil, this.helper, methRoot);
this.module.BakeMethods();
// Create delegate over "Execute" method
delExec = (ExecuteDelegate) this.module.CreateDelegate("Execute", typeof(ExecuteDelegate));
return new XmlILCommand(delExec, this.qil, this.helper.StaticData);
}
/// <summary>
/// Constructor.
/// </summary>
public XmlILCommand(ExecuteDelegate delExec, QilExpression qil, StaticDataManager staticData) {
Debug.Assert(qil != null);
this.delExec = delExec;
this.defaultWriterSettings = qil.DefaultWriterSettings;
this.wsRules = qil.WhitespaceRules;
this.names = staticData.Names;
this.prefixMappingsList = staticData.PrefixMappingsList;
this.filters = staticData.NameFilters;
this.types = staticData.XmlTypes;
this.collations = staticData.Collations;
this.globalNames = staticData.GlobalNames;
this.earlyInfo = staticData.EarlyBound;
}
private void CompileIlFromQil(XsltSettings settings) {
command = new XmlILGenerator().Generate(qil, settings.AssemblyName);
// Set outputSettings only if compilation was successful
outputSettings = qil.DefaultWriterSettings;
qil = null;
}
public static void TraceOptimizations(QilExpression qil, string fileName) {
if (!IsEnabled)
return;
XmlWriter w = XmlWriter.Create(dirName + "\\" + fileName);
w.WriteStartDocument();
w.WriteProcessingInstruction("xml-stylesheet", "href='qilo.xslt' type='text/xsl'");
w.WriteStartElement("QilOptimizer");
w.WriteAttributeString("timestamp", DateTime.Now.ToString(CultureInfo.InvariantCulture));
WriteQilRewrite(qil, w, null);
try {
// Then, rewrite the graph until "done" or some max value is reached.
for (int i = 1; i < MAX_REWRITES; i++) {
QilExpression qilTemp = (QilExpression) (new QilCloneVisitor(qil.Factory).Clone(qil));
XmlILOptimizerVisitor visitor = new XmlILOptimizerVisitor(qilTemp, !qilTemp.IsDebug);
visitor.Threshold = i;
qilTemp = visitor.Optimize();
// In debug code, ensure that QIL after N steps is correct
QilValidationVisitor.Validate(qilTemp);
// Trace the rewrite
WriteQilRewrite(qilTemp, w, OptimizationToString(visitor.LastReplacement));
if (visitor.ReplacementCount < i)
break;
}
}
catch (Exception e) {
if (!XmlException.IsCatchableException(e)) {
throw;
}
w.WriteElementString("Exception", null, e.ToString());
throw;
}
finally {
w.WriteEndElement();
w.WriteEndDocument();
w.Flush();
w.Close();
}
}
public IList <QilNode> Find(QilExpression qil)
{
Visit(qil);
return(_fwdrefs);
}
/// <summary>
/// Serialize Qil tree to writer "w".
/// </summary>
private static void WriteQil(QilExpression qil, XmlWriter w) {
QilXmlWriter qw = new QilXmlWriter(w);
qw.ToXml(qil);
}
// Do not edit this region
// It is auto-generated
#region AUTOGENERATED
#region meta
protected override QilNode VisitQilExpression(QilExpression local0)
{
QilNode local1 = local0[0];
if (this[XmlILOptimization.EliminateUnusedGlobals])
{
// PATTERN: [EliminateUnusedGlobals] $qil:(QilExpression *) => { ... }
if (AllowReplace(XmlILOptimization.EliminateUnusedGlobals, local0))
{
EliminateUnusedGlobals(local0.GlobalVariableList);
EliminateUnusedGlobals(local0.GlobalParameterList);
EliminateUnusedGlobals(local0.FunctionList);
}
}
if (this[XmlILOptimization.AnnotateConstruction])
{
// PATTERN: [AnnotateConstruction] $qil:(QilExpression *) => { ... }
if (AllowReplace(XmlILOptimization.AnnotateConstruction, local0))
{
foreach (QilFunction ndFunc in local0.FunctionList)
{
// Functions that construct Xml trees should stream output to writer; otherwise, results should
// be cached and returned.
if (IsConstructedExpression(ndFunc.Definition))
{
// Perform state analysis on function's content
ndFunc.Definition = _contentAnalyzer.Analyze(ndFunc, ndFunc.Definition);
}
}
// Perform state analysis on the root expression
local0.Root = _contentAnalyzer.Analyze(null, local0.Root);
// Make sure that root expression is pushed to writer
XmlILConstructInfo.Write(local0.Root).PushToWriterLast = true;
}
}
return NoReplace(local0);
}
public static void WriteQil(QilExpression qil, string fileName) {
if (!IsEnabled)
return;
XmlWriter w = XmlWriter.Create(dirName + "\\" + fileName);
try {
WriteQil(qil, w);
}
finally {
w.Close();
}
}
/// <summary>
/// This function is called on every recompilation to discard all previous results
/// </summary>
private void Reset() {
this.compilerResults = null;
this.outputSettings = null;
this.qil = null;
this.command = null;
}
//-----------------------------------------------
// meta
//-----------------------------------------------
public XmlQueryType CheckQilExpression(QilExpression node) {
Check(node[0].NodeType == QilNodeType.False || node[0].NodeType == QilNodeType.True, node, "IsDebug must either be True or False");
CheckLiteralValue(node[1], typeof(XmlWriterSettings));
CheckLiteralValue(node[2], typeof(IList<WhitespaceRule>));
CheckClassAndNodeType(node[3], typeof(QilList), QilNodeType.GlobalParameterList);
CheckClassAndNodeType(node[4], typeof(QilList), QilNodeType.GlobalVariableList);
CheckLiteralValue(node[5], typeof(IList<EarlyBoundInfo>));
CheckClassAndNodeType(node[6], typeof(QilList), QilNodeType.FunctionList);
return XmlQueryTypeFactory.ItemS;
}
protected override QilNode VisitQilExpression(QilExpression n)
{
return(NoReplace(n));
}
private void EndElement()
{
MethodInfo facMethod = null;
object[] facArgs;
QilList list;
QilNode nd;
ReaderAnnotation ann;
list = this.stk.Pop();
ann = (ReaderAnnotation)list.Annotation;
// Special case certain element names
string s = r.LocalName;
switch (r.LocalName)
{
case "QilExpression": {
Debug.Assert(list.Count > 0, "QilExpression node requires a Root expression");
QilExpression qil = f.QilExpression(list[list.Count - 1]);
// Be flexible on order and presence of QilExpression children
for (int i = 0; i < list.Count - 1; i++)
{
switch (list[i].NodeType)
{
case QilNodeType.True:
case QilNodeType.False:
qil.IsDebug = list[i].NodeType == QilNodeType.True;
break;
case QilNodeType.FunctionList:
qil.FunctionList = (QilList)list[i];
break;
case QilNodeType.GlobalVariableList:
qil.GlobalVariableList = (QilList)list[i];
break;
case QilNodeType.GlobalParameterList:
qil.GlobalParameterList = (QilList)list[i];
break;
}
}
nd = qil;
break;
}
case "ForwardDecls":
this.inFwdDecls = false;
return;
case "Parameter":
case "Let":
case "For":
case "Function": {
string id = ann.Id;
QilName name = ann.Name;
Debug.Assert(id != null, r.LocalName + " must have an id attribute");
Debug.Assert(!this.inFwdDecls || ann.XmlType != null, "Forward decl for " + r.LocalName + " '" + id + "' must have an xmlType attribute");
// Create node (may be discarded later if it was already declared in forward declarations section)
switch (r.LocalName)
{
case "Parameter":
Debug.Assert(list.Count <= (this.inFwdDecls ? 0 : 1), "Parameter '" + id + "' must have 0 or 1 arguments");
Debug.Assert(ann.XmlType != null, "Parameter '" + id + "' must have an xmlType attribute");
if (this.inFwdDecls || list.Count == 0)
{
nd = f.Parameter(null, name, ann.XmlType);
}
else
{
nd = f.Parameter(list[0], name, ann.XmlType);
}
break;
case "Let":
Debug.Assert(list.Count == (this.inFwdDecls ? 0 : 1), "Let '" + id + "' must have 0 or 1 arguments");
if (this.inFwdDecls)
{
nd = f.Let(f.Unknown(ann.XmlType));
}
else
{
nd = f.Let(list[0]);
}
break;
case "For":
Debug.Assert(list.Count == 1, "For '" + id + "' must have 1 argument");
nd = f.For(list[0]);
break;
default:
Debug.Assert(list.Count == (this.inFwdDecls ? 2 : 3), "Function '" + id + "' must have 2 or 3 arguments");
if (this.inFwdDecls)
{
nd = f.Function(list[0], list[1], ann.XmlType);
}
else
{
nd = f.Function(list[0], list[1], list[2], ann.XmlType != null ? ann.XmlType : list[1].XmlType);
}
break;
}
// Set DebugName
if (name != null)
{
((QilReference)nd).DebugName = name.ToString();
}
if (this.inFwdDecls)
{
Debug.Assert(!this.scope.ContainsKey(id), "Multiple nodes have id '" + id + "'");
this.fwdDecls[id] = nd;
this.scope[id] = nd;
}
else
{
if (this.fwdDecls.ContainsKey(id))
{
// Replace forward declaration
Debug.Assert(r.LocalName == Enum.GetName(typeof(QilNodeType), nd.NodeType), "Id '" + id + "' is not not bound to a " + r.LocalName + " forward decl");
nd = this.fwdDecls[id];
this.fwdDecls.Remove(id);
if (list.Count > 0)
{
nd[0] = list[0];
}
if (list.Count > 1)
{
nd[1] = list[1];
}
}
else
{
// Put reference in scope
Debug.Assert(!this.scope.ContainsKey(id), "Id '" + id + "' is already in scope");
this.scope[id] = nd;
}
}
nd.Annotation = ann;
break;
}
case "RefTo": {
// Lookup reference
string id = ann.Id;
Debug.Assert(id != null, r.LocalName + " must have an id attribute");
Debug.Assert(this.scope.ContainsKey(id), "Id '" + id + "' is not in scope");
this.stk.Peek().Add(this.scope[id]);
return;
}
case "Sequence":
nd = f.Sequence(list);
break;
case "FunctionList":
nd = f.FunctionList(list);
break;
case "GlobalVariableList":
nd = f.GlobalVariableList(list);
break;
case "GlobalParameterList":
nd = f.GlobalParameterList(list);
break;
case "ActualParameterList":
nd = f.ActualParameterList(list);
break;
case "FormalParameterList":
nd = f.FormalParameterList(list);
break;
case "SortKeyList":
nd = f.SortKeyList(list);
break;
case "BranchList":
nd = f.BranchList(list);
break;
case "XsltInvokeEarlyBound": {
Debug.Assert(ann.ClrNamespace != null, "XsltInvokeEarlyBound must have a clrNamespace attribute");
Debug.Assert(list.Count == 2, "XsltInvokeEarlyBound must have exactly 2 arguments");
Debug.Assert(list.XmlType != null, "XsltInvokeEarlyBound must have an xmlType attribute");
MethodInfo mi = null;
QilName name = (QilName)list[0];
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
Type t = asm.GetType(ann.ClrNamespace);
if (t != null)
{
mi = t.GetMethod(name.LocalName);
break;
}
}
Debug.Assert(mi != null, "Cannot find method " + ann.ClrNamespace + "." + name.ToString());
nd = f.XsltInvokeEarlyBound(name, f.LiteralObject(mi), list[1], ann.XmlType);
break;
}
default: {
// Find factory method which will be used to construct the Qil node
Debug.Assert(nameToFactoryMethod.ContainsKey(r.LocalName), "Method " + r.LocalName + " could not be found on QilFactory");
facMethod = nameToFactoryMethod[r.LocalName];
Debug.Assert(facMethod.GetParameters().Length == list.Count, "NodeType " + r.LocalName + " does not allow " + list.Count + " parameters");
// Create factory method arguments
facArgs = new object[list.Count];
for (int i = 0; i < facArgs.Length; i++)
{
facArgs[i] = list[i];
}
// Create node and set its properties
nd = (QilNode)facMethod.Invoke(f, facArgs);
break;
}
}
nd.SourceLine = list.SourceLine;
// Add node to its parent's list
this.stk.Peek().Add(nd);
}
/// <summary>
/// This function is called on every recompilation to discard all previous results
/// </summary>
private void Reset() {
compilerResults = null;
outputSettings = null;
qil = null;
command = null;
}
protected virtual QilNode VisitQilExpression(QilExpression n)
{
return(VisitChildren(n));
}
private void CompileQilToMsil(XsltSettings settings) {
this.command = new XmlILGenerator().Generate(this.qil, /*typeBuilder:*/null);
this.outputSettings = this.command.StaticData.DefaultWriterSettings;
this.qil = null;
}
