internal override void Compile(Compiler compiler)
{
CompileAttributes(compiler);
CheckRequiredAttribute(compiler, this.nameAvt, Keywords.s_Name);
this.name = PrecalculateAvt(ref this.nameAvt);
this.nsUri = PrecalculateAvt(ref this.nsAvt);
// if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
if (this.nameAvt == null && this.nsAvt == null)
{
if (this.name != Keywords.s_Xmlns)
{
this.qname = CreateElementQName(this.name, this.nsUri, compiler.CloneScopeManager());
}
}
else
{
this.manager = compiler.CloneScopeManager();
}
if (compiler.Recurse())
{
Debug.Assert(this.empty == false);
CompileTemplate(compiler);
compiler.ToParent();
}
this.empty = (this.containedActions == null);
}
private PrefixQName qname; // When we not have AVTs at all we can do this. null otherwise.
private static PrefixQName CreateAttributeQName(string name, string nsUri, InputScopeManager manager) {
// if name == "xmlns" we don't need to generate this attribute.
// to avoid i'ts generation we can return false and not add AtributeCation to it's parent container action
// for now not creating this.qname will do the trick at execution time
if (name == "xmlns") return null;
if (nsUri == XmlReservedNs.NsXmlNs) {
throw XsltException.Create(Res.Xslt_ReservedNS, nsUri);
}
PrefixQName qname = new PrefixQName();
qname.SetQName(name);
qname.Namespace = nsUri != null ? nsUri : manager.ResolveXPathNamespace(qname.Prefix);
if (qname.Prefix.StartsWith("xml", StringComparison.Ordinal)) {
if (qname.Prefix.Length == 3) { // prefix == "xml"
if (qname.Namespace == XmlReservedNs.NsXml && (qname.Name == "lang" || qname.Name == "space")) {
// preserve prefix for xml:lang and xml:space
}
else {
qname.ClearPrefix();
}
}
else if (qname.Prefix == "xmlns") {
if (qname.Namespace == XmlReservedNs.NsXmlNs) {
// if NS wasn't specified we have to use prefix to find it and this is imposible for 'xmlns'
throw XsltException.Create(Res.Xslt_InvalidPrefix, qname.Prefix);
}
else {
qname.ClearPrefix();
}
}
}
return qname;
}
internal override void Compile(Compiler compiler)
{
CompileAttributes(compiler);
CheckRequiredAttribute(compiler, _nameAvt, "name");
_name = PrecalculateAvt(ref _nameAvt);
_nsUri = PrecalculateAvt(ref _nsAvt);
// if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
if (_nameAvt == null && _nsAvt == null)
{
if (_name != "xmlns")
{
_qname = CreateAttributeQName(_name, _nsUri, compiler.CloneScopeManager());
}
}
else
{
_manager = compiler.CloneScopeManager();
}
if (compiler.Recurse())
{
CompileTemplate(compiler);
compiler.ToParent();
}
}
internal override void Compile(Compiler compiler)
{
CompileAttributes(compiler);
CheckRequiredAttribute(compiler, this.nameAvt, "name");
this.name = PrecalculateAvt(ref this.nameAvt);
this.nsUri = PrecalculateAvt(ref this.nsAvt);
// if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
if (this.nameAvt == null && this.nsAvt == null)
{
if (this.name != "xmlns")
{
this.qname = CreateAttributeQName(this.name, this.nsUri, compiler.CloneScopeManager());
}
}
else
{
this.manager = compiler.CloneScopeManager();
}
if (compiler.Recurse())
{
CompileTemplate(compiler);
compiler.ToParent();
}
}
// see http://www.w3.org/TR/xslt#function-element-available
private bool ElementAvailable(string qname)
{
string name, prefix;
PrefixQName.ParseQualifiedName(qname, out prefix, out name);
string ns = this.manager.ResolveXmlNamespace(prefix);
// msxsl:script - is not an "instruction" so we return false for it.
if (ns == Keywords.s_XsltNamespace)
{
return(
name == Keywords.s_ApplyImports ||
name == Keywords.s_ApplyTemplates ||
name == Keywords.s_Attribute ||
name == Keywords.s_CallTemplate ||
name == Keywords.s_Choose ||
name == Keywords.s_Comment ||
name == Keywords.s_Copy ||
name == Keywords.s_CopyOf ||
name == Keywords.s_Element ||
name == Keywords.s_Fallback ||
name == Keywords.s_ForEach ||
name == Keywords.s_If ||
name == Keywords.s_Message ||
name == Keywords.s_Number ||
name == Keywords.s_ProcessingInstruction ||
name == Keywords.s_Text ||
name == Keywords.s_ValueOf ||
name == Keywords.s_Variable
);
}
return(false);
}
public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
{
XsltCompileContext xsltCompileContext = (XsltCompileContext)xsltContext;
string local, prefix;
PrefixQName.ParseQualifiedName(ToString(args[0]), out prefix, out local);
string? ns = xsltContext.LookupNamespace(prefix);
XmlQualifiedName keyName = new XmlQualifiedName(local, ns);
XPathNavigator root = docContext.Clone();
root.MoveToRoot();
ArrayList?resultCollection = null;
foreach (Key key in xsltCompileContext._processor !.KeyList !)
{
if (key.Name == keyName)
{
Hashtable?keyTable = key.GetKeys(root);
if (keyTable == null)
{
keyTable = xsltCompileContext.BuildKeyTable(key, root);
key.AddKey(root, keyTable);
}
XPathNodeIterator?it = args[1] as XPathNodeIterator;
if (it != null)
{
it = it.Clone();
while (it.MoveNext())
{
resultCollection = AddToList(resultCollection, (ArrayList?)keyTable[it.Current !.Value]);
internal override void Compile(Compiler compiler)
{
CompileAttributes(compiler);
CheckRequiredAttribute(compiler, _nameAvt, "name");
_name = PrecalculateAvt(ref _nameAvt);
_nsUri = PrecalculateAvt(ref _nsAvt);
// if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
if (_nameAvt == null && _nsAvt == null)
{
if (_name != "xmlns")
{
_qname = CreateElementQName(_name, _nsUri, compiler.CloneScopeManager());
}
}
else
{
_manager = compiler.CloneScopeManager();
}
if (compiler.Recurse())
{
Debug.Assert(_empty == false);
CompileTemplate(compiler);
compiler.ToParent();
}
_empty = (this.containedActions == null);
}
// see http://www.w3.org/TR/xslt#function-element-available
private bool ElementAvailable(string qname)
{
string name, prefix;
PrefixQName.ParseQualifiedName(qname, out prefix, out name);
string ns = this.manager.ResolveXmlNamespace(prefix);
// msxsl:script - is not an "instruction" so we return false for it.
if (ns == XmlReservedNs.NsXslt)
{
return(
name == "apply-imports" ||
name == "apply-templates" ||
name == "attribute" ||
name == "call-template" ||
name == "choose" ||
name == "comment" ||
name == "copy" ||
name == "copy-of" ||
name == "element" ||
name == "fallback" ||
name == "for-each" ||
name == "if" ||
name == "message" ||
name == "number" ||
name == "processing-instruction" ||
name == "text" ||
name == "value-of" ||
name == "variable"
);
}
return(false);
}
internal XmlQualifiedName CreateXmlQName(string qname)
{
string prefix, local;
PrefixQName.ParseQualifiedName(qname, out prefix, out local);
return(new XmlQualifiedName(local, _scopeManager.ResolveXmlNamespace(prefix)));
}
internal override void Execute(Processor processor, ActionFrame frame)
{
Debug.Assert(processor != null && frame != null);
switch (frame.State)
{
case Initialized:
if (_qname != null)
{
frame.CalulatedName = _qname;
}
else
{
frame.CalulatedName = CreateElementQName(
_nameAvt == null ? _name : _nameAvt.Evaluate(processor, frame),
_nsAvt == null ? _nsUri : _nsAvt.Evaluate(processor, frame),
_manager
);
}
goto case NameDone;
case NameDone:
{
PrefixQName qname = frame.CalulatedName;
if (processor.BeginEvent(XPathNodeType.Element, qname.Prefix, qname.Name, qname.Namespace, _empty) == false)
{
// Come back later
frame.State = NameDone;
break;
}
if (!_empty)
{
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
break; // Allow children to run
}
else
{
goto case ProcessingChildren;
}
}
case ProcessingChildren:
if (processor.EndEvent(XPathNodeType.Element) == false)
{
frame.State = ProcessingChildren;
break;
}
frame.Finished();
break;
default:
Debug.Fail("Invalid ElementAction execution state");
break;
}
}
internal override void Execute(Processor processor, ActionFrame frame)
{
Debug.Assert(processor != null && frame != null);
switch (frame.State)
{
case Initialized:
if (this.qname != null)
{
frame.CalulatedName = this.qname;
}
else
{
frame.CalulatedName = CreateAttributeQName(
this.nameAvt == null ? this.name : this.nameAvt.Evaluate(processor, frame),
this.nsAvt == null ? this.nsUri : this.nsAvt.Evaluate(processor, frame),
this.manager
);
if (frame.CalulatedName == null)
{
// name == "xmlns" case. Ignore xsl:attribute
frame.Finished();
break;
}
}
goto case NameDone;
case NameDone:
{
PrefixQName qname = frame.CalulatedName;
if (processor.BeginEvent(XPathNodeType.Attribute, qname.Prefix, qname.Name, qname.Namespace, false) == false)
{
// Come back later
frame.State = NameDone;
break;
}
processor.PushActionFrame(frame);
frame.State = ProcessingChildren;
break; // Allow children to run
}
case ProcessingChildren:
if (processor.EndEvent(XPathNodeType.Attribute) == false)
{
frame.State = ProcessingChildren;
break;
}
frame.Finished();
break;
default:
Debug.Fail("Invalid ElementAction execution state");
break;
}
}
private void AddScript(Compiler compiler)
{
NavigatorInput input = compiler.Input;
ScriptingLanguage lang = ScriptingLanguage.JScript;
string implementsNamespace = null;
if (input.MoveToFirstAttribute())
{
do
{
if (input.LocalName == input.Atoms.Language)
{
string langName = input.Value;
if (
String.Compare(langName, "jscript", StringComparison.OrdinalIgnoreCase) == 0 ||
String.Compare(langName, "javascript", StringComparison.OrdinalIgnoreCase) == 0
)
{
lang = ScriptingLanguage.JScript;
}
else if (
String.Compare(langName, "c#", StringComparison.OrdinalIgnoreCase) == 0 ||
String.Compare(langName, "csharp", StringComparison.OrdinalIgnoreCase) == 0
)
{
lang = ScriptingLanguage.CSharp;
}
else
{
throw XsltException.Create(Res.Xslt_ScriptInvalidLanguage, langName);
}
}
else if (input.LocalName == input.Atoms.ImplementsPrefix)
{
if (!PrefixQName.ValidatePrefix(input.Value))
{
throw XsltException.Create(Res.Xslt_InvalidAttrValue, input.LocalName, input.Value);
}
implementsNamespace = compiler.ResolveXmlNamespace(input.Value);
}
}while (input.MoveToNextAttribute());
input.ToParent();
}
if (implementsNamespace == null)
{
throw XsltException.Create(Res.Xslt_MissingAttribute, input.Atoms.ImplementsPrefix);
}
if (!input.Recurse() || input.NodeType != XPathNodeType.Text)
{
throw XsltException.Create(Res.Xslt_ScriptEmpty);
}
compiler.AddScript(input.Value, lang, implementsNamespace, input.BaseURI, input.LineNumber);
input.ToParent();
}
// see: http://www.w3.org/TR/xslt#function-function-available
private bool FunctionAvailable(string qname)
{
string name, prefix;
PrefixQName.ParseQualifiedName(qname, out prefix, out name);
string ns = LookupNamespace(prefix);
if (ns == XmlReservedNs.NsMsxsl)
{
return(name == f_NodeSet);
}
else if (ns.Length == 0)
{
switch (name)
{
case "last":
case "position":
case "name":
case "namespace-uri":
case "local-name":
case "count":
case "id":
case "string":
case "concat":
case "starts-with":
case "contains":
case "substring-before":
case "substring-after":
case "substring":
case "string-length":
case "normalize-space":
case "translate":
case "boolean":
case "not":
case "true":
case "false":
case "lang":
case "number":
case "sum":
case "floor":
case "ceiling":
case "round":
return(true);
// XSLT functions:
default:
return(s_FunctionTable[name] != null && name != "unparsed-entity-uri");
}
}
else
{
// Is this script or extention function?
return(GetExtentionMethod(ns, name, /*argTypes*/ null, out _) != null);
}
}
// see: http://www.w3.org/TR/xslt#function-function-available
private bool FunctionAvailable(string qname)
{
string name, prefix;
PrefixQName.ParseQualifiedName(qname, out prefix, out name);
string ns = LookupNamespace(prefix);
if (ns == XmlReservedNs.NsMsxsl)
{
return(name == f_NodeSet);
}
else if (ns.Length == 0)
{
return(
// It'll be better to get this information from XPath
name == "last" ||
name == "position" ||
name == "name" ||
name == "namespace-uri" ||
name == "local-name" ||
name == "count" ||
name == "id" ||
name == "string" ||
name == "concat" ||
name == "starts-with" ||
name == "contains" ||
name == "substring-before" ||
name == "substring-after" ||
name == "substring" ||
name == "string-length" ||
name == "normalize-space" ||
name == "translate" ||
name == "boolean" ||
name == "not" ||
name == "true" ||
name == "false" ||
name == "lang" ||
name == "number" ||
name == "sum" ||
name == "floor" ||
name == "ceiling" ||
name == "round" ||
// XSLT functions:
(s_FunctionTable[name] != null && name != "unparsed-entity-uri")
);
}
else
{
// Is this script or extention function?
object extension;
return(GetExtentionMethod(ns, name, /*argTypes*/ null, out extension) != null);
}
}
private static PrefixQName?CreateAttributeQName(string name, string?nsUri, InputScopeManager?manager)
{
// if name == "xmlns" we don't need to generate this attribute.
// to avoid its generation we can return false and not add AttributeCreation to it's parent container action
// for now not creating this.qname will do the trick at execution time
if (name == "xmlns")
{
return(null);
}
if (nsUri == XmlReservedNs.NsXmlNs)
{
throw XsltException.Create(SR.Xslt_ReservedNS, nsUri);
}
PrefixQName qname = new PrefixQName();
qname.SetQName(name);
qname.Namespace = nsUri != null ? nsUri : manager !.ResolveXPathNamespace(qname.Prefix);
if (qname.Prefix.StartsWith("xml", StringComparison.Ordinal))
{
if (qname.Prefix.Length == 3)
{ // prefix == "xml"
if (qname.Namespace == XmlReservedNs.NsXml && (qname.Name == "lang" || qname.Name == "space"))
{
// preserve prefix for xml:lang and xml:space
}
else
{
qname.ClearPrefix();
}
}
else if (qname.Prefix == "xmlns")
{
if (qname.Namespace == XmlReservedNs.NsXmlNs)
{
// if NS wasn't specified we have to use prefix to find it and this is imposible for 'xmlns'
throw XsltException.Create(SR.Xslt_InvalidPrefix, qname.Prefix);
}
else
{
qname.ClearPrefix();
}
}
}
return(qname);
}
private static PrefixQName CreateElementQName(string name, string nsUri, InputScopeManager manager) {
if (nsUri == XmlReservedNs.NsXmlNs) {
throw XsltException.Create(Res.Xslt_ReservedNS, nsUri);
}
PrefixQName qname = new PrefixQName();
qname.SetQName(name);
if (nsUri == null) {
qname.Namespace = manager.ResolveXmlNamespace(qname.Prefix);
}
else {
qname.Namespace = nsUri;
}
return qname;
}
public string GetNsAlias(ref string prefix)
{
Debug.Assert(
Keywords.Equals(this.input.LocalName, this.input.Atoms.StylesheetPrefix) ||
Keywords.Equals(this.input.LocalName, this.input.Atoms.ResultPrefix)
);
if (Keywords.Compare(this.input.Atoms.HashDefault, prefix))
{
prefix = string.Empty;
return(this.DefaultNamespace);
}
else
{
if (!PrefixQName.ValidatePrefix(prefix))
{
throw XsltException.Create(Res.Xslt_InvalidAttrValue, this.input.LocalName, prefix);
}
return(this.ResolveXPathNamespace(prefix));
}
}
public string GetNsAlias(ref string prefix)
{
Debug.Assert(
Ref.Equal(_input.LocalName, _input.Atoms.StylesheetPrefix) ||
Ref.Equal(_input.LocalName, _input.Atoms.ResultPrefix)
);
if (prefix == "#default")
{
prefix = string.Empty;
return(this.DefaultNamespace);
}
else
{
if (!PrefixQName.ValidatePrefix(prefix))
{
throw XsltException.Create(SR.Xslt_InvalidAttrValue, _input.LocalName, prefix);
}
return(this.ResolveXPathNamespace(prefix));
}
}
private static PrefixQName CreateElementQName(string name, string nsUri, InputScopeManager manager)
{
if (nsUri == XmlReservedNs.NsXmlNs)
{
throw XsltException.Create(SR.Xslt_ReservedNS, nsUri);
}
PrefixQName qname = new PrefixQName();
qname.SetQName(name);
if (nsUri == null)
{
qname.Namespace = manager.ResolveXmlNamespace(qname.Prefix);
}
else
{
qname.Namespace = nsUri;
}
return(qname);
}
private String SystemProperty(string qname)
{
String result = string.Empty;
string prefix;
string local;
PrefixQName.ParseQualifiedName(qname, out prefix, out local);
// verify the prefix corresponds to the Xslt namespace
string urn = LookupNamespace(prefix);
if (urn == XmlReservedNs.NsXslt)
{
if (local == "version")
{
result = "1";
}
else if (local == "vendor")
{
result = "Microsoft";
}
else if (local == "vendor-url")
{
result = "http://www.microsoft.com";
}
}
else
{
if (urn == null && prefix != null)
{
// if prefix exist it has to be mapped to namespace.
// Can it be "" here ?
throw XsltException.Create(Res.Xslt_InvalidPrefix, prefix);
}
return(string.Empty);
}
return(result);
}
internal override void Compile(Compiler compiler) {
CompileAttributes(compiler);
CheckRequiredAttribute(compiler, this.nameAvt, Keywords.s_Name);
this.name = PrecalculateAvt(ref this.nameAvt);
this.nsUri = PrecalculateAvt(ref this.nsAvt );
// if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
if (this.nameAvt == null && this.nsAvt == null) {
if(this.name != Keywords.s_Xmlns) {
this.qname = CreateAttributeQName(this.name, this.nsUri, compiler.CloneScopeManager());
}
}
else {
this.manager = compiler.CloneScopeManager();
}
if (compiler.Recurse()) {
CompileTemplate(compiler);
compiler.ToParent();
}
}
private static double NameTest(string name)
{
if (name == "*")
{
return(-0.5);
}
int idx = name.Length - 2;
if (0 <= idx && name[idx] == ':' && name[idx + 1] == '*')
{
if (!PrefixQName.ValidatePrefix(name.Substring(0, idx)))
{
throw XsltException.Create(SR.Xslt_InvalidAttrValue, "elements", name);
}
return(-0.25);
}
else
{
PrefixQName.ParseQualifiedName(name, out _, out _);
return(0);
}
}
private DecimalFormat ResolveFormatName(string formatName)
{
string ns = string.Empty, local = string.Empty;
if (formatName != null)
{
string prefix;
PrefixQName.ParseQualifiedName(formatName, out prefix, out local);
ns = LookupNamespace(prefix);
}
DecimalFormat formatInfo = this.processor.RootAction.GetDecimalFormat(new XmlQualifiedName(local, ns));
if (formatInfo == null)
{
if (formatName != null)
{
throw XsltException.Create(Res.Xslt_NoDecimalFormat, formatName);
}
formatInfo = new DecimalFormat(new NumberFormatInfo(), '#', '0', ';');
}
return(formatInfo);
}
double NameTest(String name)
{
if (name == "*")
{
return(-0.5);
}
int idx = name.Length - 2;
if (0 <= idx && name[idx] == ':' && name[idx + 1] == '*')
{
if (!PrefixQName.ValidatePrefix(name.Substring(0, idx)))
{
throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Elements, name);
}
return(-0.25);
}
else
{
string prefix, localname;
PrefixQName.ParseQualifiedName(name, out prefix, out localname);
return(0);
}
}
private XmlDataType ParseDataType(string value, InputScopeManager manager)
{
if (value == null)
{ // Avt is not constant, or attribute wasn't defined
return(XmlDataType.Text);
}
if (value == "text")
{
return(XmlDataType.Text);
}
if (value == "number")
{
return(XmlDataType.Number);
}
String prefix, localname;
PrefixQName.ParseQualifiedName(value, out prefix, out localname);
manager.ResolveXmlNamespace(prefix);
if (prefix.Length == 0 && !_forwardCompatibility)
{
throw XsltException.Create(SR.Xslt_InvalidAttrValue, "data-type", value);
}
return(XmlDataType.Text);
}
internal override void Compile(Compiler compiler) {
CompileAttributes(compiler);
CheckRequiredAttribute(compiler, this.nameAvt, "name");
this.name = PrecalculateAvt(ref this.nameAvt);
this.nsUri = PrecalculateAvt(ref this.nsAvt );
// if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
if (this.nameAvt == null && this.nsAvt == null) {
if(this.name != "xmlns") {
this.qname = CreateElementQName(this.name, this.nsUri, compiler.CloneScopeManager());
}
}
else {
this.manager = compiler.CloneScopeManager();
}
if (compiler.Recurse()) {
Debug.Assert(this.empty == false);
CompileTemplate(compiler);
compiler.ToParent();
}
this.empty = (this.containedActions == null) ;
}
internal void SetQName(string qname)
{
PrefixQName.ParseQualifiedName(qname, out Prefix, out Name);
}
