private static OutputMethod ParseOutputMethod(string value, Compiler compiler)
{
XmlQualifiedName method = compiler.CreateXPathQName(value);
if (method.Namespace != string.Empty)
{
return(OutputMethod.Other);
}
switch (method.Name)
{
case Keywords.s_Xml:
return(OutputMethod.Xml);
case Keywords.s_Html:
return(OutputMethod.Html);
case Keywords.s_Text:
return(OutputMethod.Text);
default:
if (compiler.ForwardCompatibility)
{
return(OutputMethod.Unknown);
}
throw XsltException.InvalidAttrValue(Keywords.s_Method, value);
}
}
internal override bool CompileAttribute(Compiler compiler)
{
string name = compiler.Input.LocalName;
string value = compiler.Input.Value;
if (Keywords.Equals(name, compiler.Atoms.Level))
{
if (value != s_any && value != s_multiple && value != s_single)
{
throw XsltException.InvalidAttrValue(Keywords.s_Level, value);
}
this.level = value;
}
else if (Keywords.Equals(name, compiler.Atoms.Count))
{
this.countPattern = value;
this.countKey = compiler.AddPatternQuery(value, /*allowVars:*/ true, /*allowKey:*/ true);
}
else if (Keywords.Equals(name, compiler.Atoms.From))
{
this.from = value;
this.fromKey = compiler.AddPatternQuery(value, /*allowVars:*/ true, /*allowKey:*/ true);
}
else if (Keywords.Equals(name, compiler.Atoms.Value))
{
this.value = value;
this.valueKey = compiler.AddQuery(value);
}
else if (Keywords.Equals(name, compiler.Atoms.Format))
{
this.formatAvt = Avt.CompileAvt(compiler, value);
Debug.WriteLine("name = \"" + value + "\"");
}
else if (Keywords.Equals(name, compiler.Atoms.Lang))
{
this.langAvt = Avt.CompileAvt(compiler, value);
Debug.WriteLine("name = \"" + value + "\"");
}
else if (Keywords.Equals(name, compiler.Atoms.LetterValue))
{
this.letterAvt = Avt.CompileAvt(compiler, value);
Debug.WriteLine("name = \"" + value + "\"");
}
else if (Keywords.Equals(name, compiler.Atoms.GroupingSeparator))
{
this.groupingSepAvt = Avt.CompileAvt(compiler, value);
Debug.WriteLine("name = \"" + value + "\"");
}
else if (Keywords.Equals(name, compiler.Atoms.GroupingSize))
{
this.groupingSizeAvt = Avt.CompileAvt(compiler, value);
Debug.WriteLine("name = \"" + value + "\"");
}
else
{
return(false);
}
return(true);
}
private string ParseLetter(string letter)
{
if (letter == null || letter == "traditional" || letter == "alphabetic")
{
return(letter);
}
if (!this.forwardCompatibility)
{
throw XsltException.InvalidAttrValue(Keywords.s_LetterValue, letter);
}
return(null);
}
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.ToLower(CultureInfo.InvariantCulture); // Case insensetive !
if (langName == "jscript" || langName == "javascript")
{
lang = ScriptingLanguage.JScript;
}
else if (langName == "vb" || langName == "visualbasic")
{
lang = ScriptingLanguage.VisualBasic;
}
else if (langName == "c#" || langName == "csharp")
{
lang = ScriptingLanguage.CSharp;
}
else
{
throw new XsltException(Res.Xslt_ScriptInvalidLang, langName);
}
}
else if (input.LocalName == input.Atoms.ImplementsPrefix)
{
if (!PrefixQName.ValidatePrefix(input.Value))
{
throw XsltException.InvalidAttrValue(input.LocalName, input.Value);
}
implementsNamespace = compiler.ResolveXmlNamespace(input.Value);
}
}while (input.MoveToNextAttribute());
input.ToParent();
}
if (implementsNamespace == null)
{
throw new XsltException(Res.Xslt_MissingAttribute, input.Atoms.ImplementsPrefix);
}
if (!input.Recurse() || input.NodeType != XPathNodeType.Text)
{
throw new XsltException(Res.Xslt_ScriptEmpty);
}
compiler.AddScript(input.Value, lang, implementsNamespace, input.BaseURI, input.LineNumber);
input.ToParent();
}
internal bool CheckAttribute(bool valid, Compiler compiler)
{
if (!valid)
{
if (!compiler.ForwardCompatibility)
{
throw XsltException.InvalidAttrValue(compiler.Input.LocalName, compiler.Input.Value);
}
return(false);
}
return(true);
}
internal override void Compile(Compiler compiler)
{
CompileAttributes(compiler);
CheckEmpty(compiler);
this.forwardCompatibility = compiler.ForwardCompatibility;
this.formatList = ParseFormat(PrecalculateAvt(ref this.formatAvt));
this.letter = ParseLetter(PrecalculateAvt(ref this.letterAvt));
this.lang = PrecalculateAvt(ref this.langAvt);
this.groupingSep = PrecalculateAvt(ref this.groupingSepAvt);
if (this.groupingSep != null && this.groupingSep.Length > 1)
{
throw XsltException.InvalidAttrValue(compiler.Atoms.GroupingSeparator, this.groupingSep);
}
this.groupingSize = PrecalculateAvt(ref this.groupingSizeAvt);
}
private string ParseLang(string value)
{
if (value == null) // Avt is not constant, or attribute wasn't defined
{
return(null);
}
if (!XmlComplianceUtil.IsValidLanguageID(value.ToCharArray(), 0, value.Length))
{
if (this.forwardCompatibility)
{
return(null);
}
throw XsltException.InvalidAttrValue(Keywords.s_Lang, value);
}
return(value);
}
//
// Attribute parsing support
//
internal bool GetYesNo(string value)
{
Debug.Assert(value != null);
Debug.Assert((object)value == (object)Input.Value); // this is always true. Why we passing value to this function.
// if (value == null)
// return false; // in XSLT it happens that default value was always false;
if (value.Equals(Atoms.Yes))
{
return(true);
}
if (value.Equals(Atoms.No))
{
return(false);
}
throw XsltException.InvalidAttrValue(Input.LocalName, value);
}
internal override bool CompileAttribute(Compiler compiler)
{
string name = compiler.Input.LocalName;
string value = compiler.Input.Value;
if (Keywords.Equals(name, compiler.Atoms.Match))
{
Debug.Assert(this.match == null);
this.match = value;
this.matchKey = compiler.AddPatternQuery(value, /*allowVars:*/ false, /*allowKey:*/ true);
Debug.WriteLine("match attribute found: \"" + this.match + "\" (#" + this.matchKey + ")");
}
else if (Keywords.Equals(name, compiler.Atoms.Name))
{
Debug.Assert(this.name == null);
this.name = compiler.CreateXPathQName(value);
Debug.WriteLine("name attribute found: " + this.name);
}
else if (Keywords.Equals(name, compiler.Atoms.Priority))
{
Debug.Assert(Double.IsNaN(this.priority));
this.priority = XmlConvert.ToXPathDouble(value);
if (double.IsNaN(this.priority) && !compiler.ForwardCompatibility)
{
throw XsltException.InvalidAttrValue(Keywords.s_Priority, value);
}
}
else if (Keywords.Equals(name, compiler.Atoms.Mode))
{
Debug.Assert(this.mode == null);
if (compiler.AllowBuiltInMode && value.Trim() == "*")
{
this.mode = Compiler.BuiltInMode;
}
else
{
this.mode = compiler.CreateXPathQName(value);
}
Debug.WriteLine("mode attribute found: " + this.mode);
}
else
{
return(false);
}
return(true);
}
void NameTest(String name, Compiler compiler)
{
if (name == "*")
{
return;
}
if (name.EndsWith(":*"))
{
if (!PrefixQName.ValidatePrefix(name.Substring(0, name.Length - 3)))
{
throw XsltException.InvalidAttrValue(compiler.Input.LocalName, name);
}
}
else
{
string prefix, localname;
PrefixQName.ParseQualifiedName(name, out prefix, out localname);
}
}
private XmlCaseOrder ParseCaseOrder(string value)
{
if (value == null) // Avt is not constant, or attribute wasn't defined
{
return(XmlCaseOrder.None);
}
if (value == Keywords.s_UpperFirst)
{
return(XmlCaseOrder.UpperFirst);
}
if (value == Keywords.s_LowerFirst)
{
return(XmlCaseOrder.LowerFirst);
}
if (this.forwardCompatibility)
{
return(XmlCaseOrder.None);
}
throw XsltException.InvalidAttrValue(Keywords.s_CaseOrder, value);
}
private XmlSortOrder ParseOrder(string value)
{
if (value == null) // Avt is not constant, or attribute wasn't defined
{
return(XmlSortOrder.Ascending);
}
if (value == Keywords.s_Ascending)
{
return(XmlSortOrder.Ascending);
}
if (value == Keywords.s_Descending)
{
return(XmlSortOrder.Descending);
}
if (this.forwardCompatibility)
{
return(XmlSortOrder.Ascending);
}
throw XsltException.InvalidAttrValue(Keywords.s_Order, value);
}
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) || prefix.Length == 0)
{
throw XsltException.InvalidAttrValue(this.input.LocalName, prefix);
}
return(this.ResolveXPathNamespace(prefix));
}
}
private XmlDataType ParseDataType(string value, InputScopeManager manager)
{
if (value == null) // Avt is not constant, or attribute wasn't defined
{
return(XmlDataType.Text);
}
if (value == Keywords.s_Text)
{
return(XmlDataType.Text);
}
if (value == Keywords.s_Number)
{
return(XmlDataType.Number);
}
String prefix, localname;
PrefixQName.ParseQualifiedName(value, out prefix, out localname);
manager.ResolveXmlNamespace(prefix);
if (prefix == String.Empty && !this.forwardCompatibility)
{
throw XsltException.InvalidAttrValue(Keywords.s_DataType, value);
}
return(XmlDataType.Text);
}
internal void CompileStylesheetAttributes(Compiler compiler)
{
NavigatorInput input = compiler.Input;
string element = input.LocalName;
string badAttribute = null;
string version = null;
if (input.MoveToFirstAttribute())
{
do
{
Debug.TraceAttribute(input);
string nspace = input.NamespaceURI;
string name = input.LocalName;
if (!Keywords.Equals(nspace, input.Atoms.Empty))
{
continue;
}
Debug.WriteLine("Attribute name: \"" + name + "\"");
if (Keywords.Equals(name, input.Atoms.Version))
{
version = input.Value;
if (1 <= XmlConvert.ToXPathDouble(version))
{
compiler.ForwardCompatibility = (version != Keywords.s_Version10);
}
else
{
// XmlConvert.ToXPathDouble(version) an be NaN!
if (!compiler.ForwardCompatibility)
{
throw XsltException.InvalidAttrValue(Keywords.s_Version, version);
}
}
Debug.WriteLine("Version found: \"" + version + "\"");
}
else if (Keywords.Equals(name, input.Atoms.ExtensionElementPrefixes))
{
compiler.InsertExtensionNamespace(input.Value);
}
else if (Keywords.Equals(name, input.Atoms.ExcludeResultPrefixes))
{
compiler.InsertExcludedNamespace(input.Value);
}
else if (Keywords.Equals(name, input.Atoms.Id))
{
// Do nothing here.
}
else
{
// We can have version atribute later. For now remember this attribute and continue
badAttribute = name;
}
}while(input.MoveToNextAttribute());
input.ToParent();
}
if (version == null)
{
throw new XsltException(Res.Xslt_MissingAttribute, Keywords.s_Version);
}
if (badAttribute != null && !compiler.ForwardCompatibility)
{
throw XsltException.InvalidAttribute(element, badAttribute);
}
}
