internal XmlElementTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type,
String name, int nameOffset, int nameLength, int nameColonPos,
int depth, bool isEmpty) : base(scanner, nsMgr, type, depth)
{
_NameColonPos = nameColonPos;
_Name = (name == null) ? _Scanner.GetTextAtom(nameOffset, nameLength) : _Scanner.GetTextAtom(name);
}
protected void LoadLog(XmlScanner scanner)
{
List <LogLevelResolver> list;
list = new List <LogLevelResolver>();
if (!scanner.GetAttributeAsBoolean("reset", false))
{
LogLevelResolver[] remaining;
remaining = this._manager.LogLevelResolvers;
foreach (LogLevelResolver resolver in remaining)
{
list.Add(resolver);
}
}
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
switch (child.Name)
{
case "Pattern":
list.Add(this.ReadLogPattern(child));
break;
default:
throw scanner.CreateXmlException(
"unexpected element <{0}/> in <Log/>",
child.Name);
}
}
this._manager.Update(list.ToArray());
}
protected Appender ReadAppenderPipeline(XmlScanner scanner)
{
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
switch (child.Name)
{
case "Synchronized":
return(new Synchronized(
this.ReadAppenderPipeline(child)));
case "AutoFlush":
return(new AutoFlush(
this.ReadAppenderPipeline(child)));
case "CloseShield":
return(new CloseShield(
this.ReadAppenderPipeline(child)));
case "Final":
return(this.ReadAppenderPipelineFinal(child));
default:
throw child.CreateXmlException(
"unexpected element <{0}/> in appender pipeline",
child.Name);
}
}
throw scanner.CreateXmlException(
"missing <Final/> in appender pipeline");
}
internal XmlEntityReader(XmlScanner scanner, XmlNameTable nt, XmlNamespaceManager nsMgr, XmlNodeType node, String entityName, int depth, Encoding encoding, String baseURI,
bool isExternal, bool isAttributeText, bool standAlone, String originalBaseURI) :
base((scanner == null ? new XmlScanner(new StringReader("a"), nt) : scanner), nt, nsMgr, node, depth, encoding, baseURI, isExternal, standAlone)
{
if (scanner == null)
{
_IsScanner = false;
_AttributeTextToken = new XmlNSAttributeTokenInfo(_Scanner, _NsMgr, XmlNodeType.Text, Normalization, _XmlNs);
_AttributeTextToken.Value = String.Empty;
_AttributeTextToken.Depth = depth + 1;
}
else
{
_IsScanner = true;
}
_IsExternal = isExternal;
//We only need to return the EndEntity token when EntityHandling = ExpandCharEntity
_EndEntityToken = new XmlNameValueTokenInfo(_Scanner, _NsMgr, XmlNodeType.EndEntity, depth - 1, String.Empty, false);
_EndEntityToken.Name = entityName;
_EndEntityEncoding = encoding;
_IsAttributeText = isAttributeText;
_PrevXmlSpace = XmlSpace.None;
_PrevXmlLang = String.Empty;
_OriginalBaseUri = originalBaseURI;
}
protected void LoadUseField(XmlScanner scanner)
{
Dictionary <string, string> properties;
properties = new Dictionary <string, string>();
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
switch (child.Name)
{
case "Property":
properties[child.GetAttributeAsString("name")] =
child.Text();
break;
default:
throw scanner.CreateXmlException(
"unexpected element <{0}/> in <Field/>",
child.Name);
}
}
this.Set(
scanner.GetAttributeAsString("name"),
scanner.Parent.GetAttributeAsString("name"),
properties);
}
internal virtual void SetName(XmlScanner scanner, String nameWPrefix, int nameColonPos, int depth, bool isDefault)
{
_Scanner = scanner;
_Depth = depth;
_IsDefault = isDefault;
_NameWPrefix = nameWPrefix;
}
internal XmlNameValueTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type,
int depth, String value, bool nor) :
base(scanner, nsMgr, type, depth, nor)
{
_Name = String.Empty;
base.SetValue(scanner, value, -1, -1);
}
internal XmlWSTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type,
int depth,
bool nor) : base(scanner, nsMgr, type, depth, nor)
{
_Name = String.Empty;
_RawValue = String.Empty;
}
protected void LoadAppender(XmlScanner scanner)
{
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
switch (child.Name)
{
case "Pipeline":
this.LoadAppenderPipeline(child);
break;
case "Format":
this.LoadAppenderFormat(child);
break;
default:
throw scanner.CreateXmlException(
"unexpected element <{0}/> in <Appender/>",
child.Name);
}
}
}
internal override int skipByteOrderMark(byte[] bytes, int byteIndex)
{
if (XmlScanner.AutoDetectEncoding(bytes, byteIndex) == 9)
{
return(4);
}
return(0);
}
internal XmlAttributeTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, bool nor) : this()
{
_NsMgr = nsMgr;
_Scanner = scanner;
_NodeType = type;
_NormalizeText = nor;
_HasNormalize = !_NormalizeText;
}
internal XmlBasicTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, int depth)
{
_Scanner = scanner;
_NsMgr = nsMgr;
_NodeType = type;
_Depth = depth;
_LineNum = 0;
_LinePos = 0;
}
internal override void SetName(XmlScanner scanner, int offset, int length, int colon, int depth)
{
_Scanner = scanner;
_NameColonPos = colon;
_Depth = depth;
_NameWPrefix = _Scanner.GetTextAtom(offset, length);
_SchemaType = null;
_TypedValue = null;
}
internal override void SetName(XmlScanner scanner, String nameWPrefix, int nameColonPos, int depth, bool isDefault)
{
_Scanner = scanner;
_NameColonPos = nameColonPos;
_Depth = depth;
_IsDefault = isDefault;
_NameWPrefix = nameWPrefix;
_RawValue = String.Empty;
_Name = null;
}
internal void SetName(String nameWPrefix, String localName, String prefix,
String ns, int depth, XmlScanner scanner)
{
_NameWPrefix = nameWPrefix;
_Name = localName;
_Prefix = prefix;
_NamespaceURI = ns;
_Depth = depth;
_Scanner = scanner;
}
protected LogLevelResolver ReadLogPattern(XmlScanner scanner)
{
return(LogLevelResolvers.LogMatches(
LogMatchers.NameMatchesPattern(
scanner.Text().Trim()),
scanner.GetAttributeAsEnum <LogLevel>(
typeof(LogLevel),
"level",
true)));
}
internal virtual void SetValue(XmlScanner scanner, String value, int offset, int length)
{
_Scanner = scanner;
_Normalizer = null;
_Value = value;
_ValueOffset = offset;
_ValueLength = length;
_HasNormalize = !_NormalizeText;
_SchemaType = null;
_TypedValue = null;
}
internal override void SetName(XmlScanner scanner, String nameWPrefix, int nameColonPos, int depth, bool isDefault)
{
_Scanner = scanner;
_NameColonPos = nameColonPos;
_Depth = depth;
_IsDefault = isDefault;
_NameWPrefix = nameWPrefix;
// PERF - we now do this instead of calling reset.
_RawValue = String.Empty;
_Name = null;
}
internal XmlNSElementTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, String name, int nameOffset, int nameLength, int nameColonPos,
int depth, bool isEmpty) : base(scanner, nsMgr, type, depth)
{
_NsMgr = nsMgr;
_Scanner = scanner;
_NameColonPos = nameColonPos;
_NameWPrefix = String.Empty;
_Name = String.Empty;
_Prefix = String.Empty;
_NamespaceURI = String.Empty;
}
internal XmlValueTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type,
int depth, bool nor) :
base(scanner, nsMgr, type, depth)
{
_ValueOffset = -1;
_ValueLength = -1;
_Value = null;
_Normalizer = null;
_RawValue = String.Empty;
_NormalizeText = nor;
_HasNormalize = !_NormalizeText;
}
public static void ParseRSS(string filename)
{
try {
XmlScanner scanner = new XmlScanner(filename);
XmlParser parser = new XmlParser(scanner);
parser.Parse();
Console.WriteLine(parser.rss);
} catch (FatalError e) {
Console.WriteLine("-- " + e.Message);
}
}
public void Load(XmlReader reader)
{
XmlScanner scanner;
scanner = new XmlScanner(reader);
try
{
this.Load(scanner);
}
finally
{
scanner.Close();
}
}
public void Load(Stream stream)
{
XmlScanner scanner;
scanner = new XmlScanner(stream);
try
{
this.Load(scanner);
}
finally
{
scanner.Close();
}
}
internal void SetValue(XmlScanner scanner, String value, int offset, int length, bool bIsCDataNormalized)
{
_Scanner = scanner;
_ExpandValue = value;
_Value = null;
_IgnoreValue = null;
_ValueOffset = offset;
_ValueLength = length;
_RawValue = value;
_HasNormalize = !_NormalizeText;
_IsCDataNormalized = bIsCDataNormalized;
_SchemaType = null;
_TypedValue = null;
}
protected void Load(XmlScanner scanner)
{
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
switch (child.Name)
{
case "LogProcessId":
this._manager.LogProcessId =
child.GetAttributeAsBoolean("value");
break;
case "LogManagedThreadId":
this._manager.LogManagedThreadId =
child.GetAttributeAsBoolean("value");
break;
case "LogFrameDepth":
this._manager.LogFrameDepth =
child.GetAttributeAsInt32("value");
break;
case "LogExtendedFrame":
this._manager.LogExtendedFrame =
child.GetAttributeAsBoolean("value");
break;
case "Appender":
this.LoadAppender(child);
break;
case "Log":
this.LoadLog(child);
break;
default:
throw scanner.CreateXmlException(
"unexpected element <{0}/>",
child.Name);
}
}
}
protected void LoadAppenderFormat(XmlScanner scanner)
{
FormatAppender formatter;
formatter = (FormatAppender)this._manager.Appender.Unwrap(
typeof(FormatAppender));
if (formatter == null)
{
return;
}
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
switch (child.Name)
{
case "NewLine":
formatter.NewLine =
this.ReadAppenderFormat(child);
break;
case "Message":
formatter.MessageFormat =
this.ReadAppenderFormat(child);
break;
case "Frame":
formatter.FrameFormat =
this.ReadAppenderFormat(child);
break;
case "Cause":
formatter.CauseFormat =
this.ReadAppenderFormat(child);
break;
default:
throw scanner.CreateXmlException(
"unexpected element <{0}/> in <Format/>",
child.Name);
}
}
}
protected void LoadAppenderPipeline(XmlScanner scanner)
{
FormatAppender before;
FormatAppender after;
before = (FormatAppender)this._manager.Appender.Unwrap(
typeof(FormatAppender));
this._manager.Appender = this.ReadAppenderPipeline(scanner);
after = (FormatAppender)this._manager.Appender.Unwrap(
typeof(FormatAppender));
if (before != null && after != null)
{
after.NewLine = before.NewLine;
after.MessageFormat = before.MessageFormat;
after.FrameFormat = before.FrameFormat;
after.CauseFormat = before.CauseFormat;
}
}
protected string ReadAppenderFormat(XmlScanner scanner)
{
StringBuilder builder;
builder = new StringBuilder();
foreach (XmlScanner child in scanner.Read())
{
if (child.IsElement)
{
switch (child.Name)
{
case "Space":
builder.Append(' ');
break;
case "CarriageReturn":
builder.Append('\r');
break;
case "LineFeed":
builder.Append('\n');
break;
default:
throw scanner.CreateXmlException(
"unexpected element <{0}/> in format text",
child.Name);
}
}
else
{
string[] lines;
lines = child.Value.Split(
_readAppenderFormatNewLineChars,
StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lines)
{
builder.Append(line.Trim());
}
}
}
return(builder.ToString());
}
protected void Load(XmlScanner scanner)
{
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
switch (child.Name)
{
case "Use":
this.LoadUse(child);
break;
default:
throw scanner.CreateXmlException(
"unexpected element <{0}/>",
child.Name);
}
}
}
protected Appender ReadAppenderPipelineFinal(XmlScanner scanner)
{
Dictionary <string, string> properties;
properties = new Dictionary <string, string>();
foreach (XmlScanner child in scanner.Read())
{
if (!child.IsElement)
{
continue;
}
if (child.Name != "Property")
{
throw scanner.CreateXmlException(
"unexpected element <{0}/> in <Final/>",
child.Name);
}
properties[child.GetAttributeAsString("name")] = child.Text();
}
return(this.CreateAppenderPipelineFinal(
scanner.GetAttributeAsString("name"),
properties));
}
internal DtdParser(XmlScanner pScanner,
XmlReader reader,
XmlResolver res,
XmlNameTable nameTable,
ValidationEventHandler validationEventHandler,
bool namespaces) {
_NameTable = nameTable;
_SchemaNames = new SchemaNames(nameTable);
_NsMgr = new XmlNamespaceManager(_NameTable);
_Scanner = _XmlScanner = pScanner;
_Scanner.InDTD = true;
_XmlResolver = res;
_Namespaces = namespaces;
_Reader = reader;
_ValidationEventHandler = validationEventHandler;
_InternalValidationEventHandler = new ValidationEventHandler(InternalValidationCallback);
_SchemaInfo = new SchemaInfo(_SchemaNames);
_SchemaInfo.SchemaType = SchemaType.DTD;
_DtdFuncIndex = DtdFunctionIndex.ParseDocTypeDecl;
_IsInternal = true;
_ParseStack = new HWStack(STACK_INCREMENT);
_ScannerStack = new HWStack(STACK_INCREMENT);
_GroupStack = new HWStack(STACK_INCREMENT);
_StringBuilder = new StringBuilder();
_L = -2;
if (_XmlResolver != null && reader.BaseURI != string.Empty) {
_BaseUri = _XmlResolver.ResolveUri(null, reader.BaseURI);
_DocBaseUri = XmlUrlResolver.UnEscape(_BaseUri.ToString());
}
Push(DtdFunctionIndex.ParseDocTypeDecl);
}
private bool HandlePERef() {
SchemaEntity en = (SchemaEntity)_SchemaInfo.ParameterEntities[GetName(XmlToken.NAME, false)];
_Scanner.Advance(); //skip ';'
if (en != null) {
if (!en.IsProcessed) {
Uri uri = _BaseUri;
XmlScanner scanner = null;
if (en.IsExternal) {
if (_XmlResolver != null) {
uri = _XmlResolver.ResolveUri(_BaseUri, en.Url);
Stream stm = (Stream)_XmlResolver.GetEntity(uri, null, null);
scanner = new XmlScanner(new XmlStreamReader(stm), _NameTable);
}
}
else if (en.Text != string.Empty) {
scanner = new XmlScanner(en.Text.ToCharArray(), _NameTable, en.Line, en.Pos + 1);
}
if (scanner != null) {
PushScanner(scanner, en, uri);
return true;
}
}
else {
// well-formness error, see xml spec [68]
throw new XmlException(Res.Xml_RecursiveParEntity, en.Name.Name, _Scanner.StartLineNum, _Scanner.StartLinePos);
}
}
else {
// Validtion error, see xml spec [68]
SendValidationEvent(Res.Xml_UndeclaredParEntity, _Scanner.GetText());
}
return false;
}
private void PushScanner(XmlScanner scanner, SchemaEntity en, Uri baseUrl) {
DtdScannerState s;
if (en != null && _L >= 0 && _HasTerminal) {
SendValidationEvent(Res.Sch_ParEntityRefNesting, null);
}
s = (DtdScannerState)_ScannerStack.Push();
if (s == null) {
s = new DtdScannerState();
_ScannerStack[_ScannerStack.Length-1] = s;
}
s._Scanner = _Scanner;
s._En = en;
s._IsInternal = _IsInternal;
s._L = _L;
s._IncludeDepth = _IncludeDepth;
s._IgnoreDepth = _IgnoreDepth;
s._BaseUri = _BaseUri;
_Scanner = scanner;
_Scanner.InDTD = true;
_BaseUri = baseUrl;
if (en != null) {
_HasSeenWhiteSpace = en.IsParEntity;
en.IsProcessed = true;
if (_IsInternal)
_IsInternal = !en.IsExternal;
_HasSeenContent = !en.IsExternal;
}
}
private void PopScanner() {
_Scanner.Close();
DtdScannerState s = (DtdScannerState)_ScannerStack.Pop();
if (s != null) {
if (s._IgnoreDepth != _IgnoreDepth ||
s._IncludeDepth != _IncludeDepth ||
s._L != _L ||
(_L >= 0 && !_HasTerminal)) {
SendValidationEvent(Res.Sch_ParEntityRefNesting, null);
}
_Scanner = s._Scanner;
_IsInternal = s._IsInternal;
_BaseUri = s._BaseUri;
if (s._En != null) {
_HasSeenWhiteSpace = s._En.IsParEntity;
s._En.IsProcessed = false;
}
}
else {
_Scanner = null;
}
}
private string ExpandAttValue(string s, ref bool fEntityRef, int lineNum, int linePos) {
if (s.Length == 0)
return s;
string code = null;
string msg = null;
char ch;
XmlScanner scanner = _Scanner;
_StringBuilder.Length = 0;
_Scanner = new XmlScanner(s.ToCharArray(), _NameTable, lineNum, linePos);
while (true) {
_Token = _Scanner.ScanLiteral(true, false, false, false);
switch (_Token) {
case XmlToken.EOF:
PopAttValueScanner();
if (_Scanner == null) {
_Scanner = scanner;
return _StringBuilder.ToString();
}
break;
case XmlToken.ENTITYREF:
fEntityRef = true;
_Scanner.InDTD = false;
ch = _Scanner.ScanNamedEntity();
_Scanner.InDTD = true;
if (ch == 0) {
XmlQualifiedName name = new XmlQualifiedName(_Scanner.GetTextAtom());
_Scanner.Advance();
SchemaEntity en = (SchemaEntity)_SchemaInfo.GeneralEntities[name];
if (en != null) {
if (!en.IsExternal) {
if (!en.IsProcessed) {
if (en.Text != null && en.Text != string.Empty) {
PushAttValueScanner(_Scanner, en);
_Scanner = new XmlScanner(en.Text.ToCharArray(), _NameTable, en.Line, en.Pos + 1);
}
}
else {
// well-formness error, see xml spec [68]
code = Res.Xml_RecursiveGenEntity;
msg = name.Name;
goto error;
}
}
else {
// well-formness error, see xml spec [68]
code = Res.Xml_ExternalEntityInAttValue;
msg = name.Name;
goto error;
}
}
else {
// well-formness error, see xml spec [68]
code = Res.Xml_UndeclaredEntity;
msg = name.Name;
if(_IsInternal) {
goto error;
}
else {
SendValidationEvent(code, msg);
}
}
}
else {
_Scanner.Advance();
_StringBuilder.Append(ch);
}
break;
case XmlToken.NUMENTREF:
fEntityRef = true;
_StringBuilder.Append(_Scanner.ScanDecEntity());
break;
case XmlToken.HEXENTREF:
fEntityRef = true;
_StringBuilder.Append(_Scanner.ScanHexEntity());
break;
case XmlToken.TEXT:
_StringBuilder.Append(_Scanner.GetText());
break;
default:
code = Res.Xml_UnexpectedToken;
goto error;
}
}
error:
Debug.Assert(code != null);
throw new XmlException(code, msg, _Scanner.StartLineNum , _Scanner.StartLinePos);
}
private void PushAttValueScanner(XmlScanner scanner, SchemaEntity en) {
if (_AttValueScannerStack == null) {
_AttValueScannerStack = new HWStack(STACK_INCREMENT);
}
DtdScannerState s = (DtdScannerState)_AttValueScannerStack.Push();
if (s == null) {
s = new DtdScannerState();
_AttValueScannerStack[_AttValueScannerStack.Length-1] = s;
}
s._Scanner = _Scanner;
s._En = en;
en.IsProcessed = true;
}
private void PopAttValueScanner() {
_Scanner.Close();
if (_AttValueScannerStack != null) {
DtdScannerState s = (DtdScannerState)_AttValueScannerStack.Pop();
if (s != null) {
s._En.IsProcessed = false;
_Scanner = s._Scanner;
}
else {
_Scanner = null;
}
}
else {
_Scanner = null;
}
}
