private void SetLiteralValues(XmlAttributeTokenInfo fld) {
//
// get the literal token
//
_Scanner.ScanToken(XmlToken.EQUALS);
_Scanner.ScanToken(XmlToken.QUOTE);
String nameWPrefix = fld.NameWPrefix;
int nameLength = nameWPrefix.Length;
fld.QuoteChar = _Scanner.QuoteChar();
fld.NsAttribute = false;
//
// always expand literals and we also need to remember the value offsets
//
int pos = _Scanner.CurrentPos;
int lineNum = _Scanner.LineNum;
int linePos = _Scanner.AbsoluteLinePos;
if (_Scanner.ScanLiteral()) {
_Scanner.CurrentPos = pos;
_Scanner.AbsoluteLinePos = linePos;
_Scanner.LineNum = lineNum;
fld.ValueContainEntity = ValueContainEntity.None;
ExpandLiteral(fld);
}
else {
fld.ValueContainEntity = ValueContainEntity.None;
fld.SetValue(_Scanner, null, _Scanner.StartPos, _Scanner.TextLength);
}
// check xmlns, xml:space, xml:lang
//
if (nameWPrefix[0] != 'x' || nameLength < 5) {
goto cleanup;
}
if (nameWPrefix[1] == 'm' && nameWPrefix[2] == 'l') {
if (nameWPrefix[3] == 'n' && nameWPrefix[4] == 's') {
fld.NsAttribute = true;
fld.FixNSNames();
}
else if ((Object)nameWPrefix == (Object)_XmlSpaceAtom) {
//
// xml:space
//
String val = fld.GetValue();
_XmlSpace = ConvertXmlSpace(val, fld.LineNum, fld.LinePos );
goto cleanup;
}
else if ((Object)nameWPrefix == (Object)_XmlLangAtom) {
//
// xml:lang
//
_XmlLang = fld.GetValue();
goto cleanup;
}
}
cleanup:
return;
}
//
// fields collection
//
private void AddAttribute() {
_Used++;
if (_Used >= _MaxCount) {
XmlAttributeTokenInfo[] expandFields=null;
int oldCount = _MaxCount;
_MaxCount = (_MaxCount + 10) * 2;
if (_CheckNamespaces)
expandFields = new XmlNSAttributeTokenInfo[_MaxCount];
else
expandFields = new XmlAttributeTokenInfo[_MaxCount];
if (_Fields != null)
Array.Copy(_Fields, 0, expandFields, 0, oldCount);
if (_CheckNamespaces) {
for (int i = oldCount; i < _MaxCount; i++) {
expandFields[i] = (XmlAttributeTokenInfo) new XmlNSAttributeTokenInfo(_Scanner, _NsMgr, XmlNodeType.Attribute, _Normalization, _XmlNs);
}
}
else {
for (int i = oldCount; i < _MaxCount; i++) {
expandFields[i] = new XmlAttributeTokenInfo(_Scanner, _NsMgr, XmlNodeType.Attribute, _Normalization);
}
}
_Fields = expandFields;
}
}
private void Init() {
if (_Scanner == null) {
CreateScanner();
}
_Scanner.Normalization = Normalization;
_Scanner.NamespaceSupport = _CheckNamespaces;
if (_Encoding == null) {
_Encoding = _Scanner.Encoding;
}
_TextToken = new XmlWSTokenInfo(_Scanner, _NsMgr, XmlNodeType.Text, -1, _Normalization);
_WhitespaceToken = new XmlWSTokenInfo(_Scanner, _NsMgr, XmlNodeType.Whitespace, -1, _Normalization);
_ERToken = new XmlNameValueTokenInfo(_Scanner, _NsMgr, XmlNodeType.EntityReference, -1, String.Empty, false);
if (_CheckNamespaces) {
_TmpToken = new XmlNSElementTokenInfo(_Scanner, _NsMgr, XmlNodeType.None, String.Empty,-1, -1, -1, 0,false);
_ElementToken = new XmlNSElementTokenInfo(_Scanner, _NsMgr, XmlNodeType.Element, String.Empty,-1, -1, -1, -1,false);
_EndElementToken = new XmlNSElementTokenInfo(_Scanner, _NsMgr, XmlNodeType.EndElement, String.Empty,-1, -1, -1, -1,false);
_AttributeTextToken = new XmlNSAttributeTokenInfo(_Scanner, _NsMgr, XmlNodeType.Text, _Normalization, _XmlNs);
}
else {
_TmpToken = new XmlElementTokenInfo(_Scanner, _NsMgr, XmlNodeType.None, String.Empty,-1, -1, -1, 0, false);
_ElementToken = new XmlElementTokenInfo(_Scanner, _NsMgr, XmlNodeType.Element, String.Empty,-1, -1, -1, -1, false);
_EndElementToken = new XmlElementTokenInfo(_Scanner, _NsMgr, XmlNodeType.Element, String.Empty,-1, -1, -1, -1, false);
_AttributeTextToken = new XmlAttributeTokenInfo(_Scanner, _NsMgr, XmlNodeType.Text, _Normalization);
}
_CurrentToken = _TmpToken;
}
private void PushScanner(XmlScanner newScanner, object entity, String baseURI, XmlAttributeTokenInfo[] fields,
int readCount, int usedCount, int lastToken, int nextFunction, bool depthIncrement,
String entityName, int depth, Encoding encoding, bool standalone, bool oldExternal,
bool newExternal) {
ScannerInfo ei = (ScannerInfo)_ScannerStack.Push();
if (ei == null) {
ei = new ScannerInfo();
_ScannerStack[_ScannerStack.Length-1] = ei;
}
ei._Scanner = _Scanner;
ei._Entity = entity;
ei._BaseURI = baseURI;
ei._LastToken = lastToken;
ei._NextFunction = nextFunction;
ei._DepthIncrement = depthIncrement;
ei._Fields = fields;
ei._ReadCount = readCount;
ei._Used = usedCount;
ei._EntityName = entityName;
ei._EntityDepth = depth;
ei._Encoding = encoding;
ei._StandAlone = standalone;
ei._IsExternal = oldExternal;
_MaxCount = 0;
//
// reset xmldecl flag
//
_CantHaveXmlDecl = false;
if (depthIncrement) {
if (readCount != -1 && fields != null && fields[readCount] != null)
fields[readCount].Depth++;
else
_ElementDepth++;
}
_Scanner = newScanner;
if (newExternal)
_Encoding = _Scanner.Encoding;
}
// This method parses the entire attribute value expanding all the entities
// it finds into an internal buffer.
private void ExpandLiteral(XmlAttributeTokenInfo currToken) {
// use our little buffer to build up the expanded attribute value.
_StringBuilder.Length = 0;
int start = _Scanner.CurrentPos;
int token = _Scanner.ScanLiteral(true, false, true, false);
char ch;
int offset = 0;
int length = 0;
char[] array = null;
bool expanded = false;
int depth = 0;
while (token != XmlToken.ENDQUOTE) {
if (!expanded && length != 0) {
// must have more than one text token, so it's time to buffer up.
expanded = true;
_StringBuilder.Append(array, offset, length);
}
switch (token) {
case XmlToken.TEXT:
if (!expanded) {
array = _Scanner.InternalBuffer;
offset = _Scanner.TextOffset;
length = _Scanner.TextLength;
}
else {
_StringBuilder.Append(_Scanner.InternalBuffer, _Scanner.TextOffset, _Scanner.TextLength);
}
break;
case XmlToken.ENTITYREF:
expanded = true;
ch = _Scanner.ScanNamedEntity();
//
// ch == 0 if general entity
// ch != 0 if build in entity, for example: <
//
if (ch == 0) {
_StringBuilder.Append(_Scanner.InternalBuffer, _Scanner.TextOffset-1, _Scanner.TextLength+1);
currToken.ValueContainEntity = ValueContainEntity.NotResolved;
//currToken.UndeclaredEntity = true;
break;
}
else {
_StringBuilder.Append(ch);
_Scanner.Advance(); // consume the ';'
}
break;
case XmlToken.HEXENTREF:
expanded = true;
_StringBuilder.Append(_Scanner.ScanHexEntity());
break;
case XmlToken.NUMENTREF:
expanded = true;
_StringBuilder.Append(_Scanner.ScanDecEntity());
break;
case XmlToken.EOF:
depth--;
break;
}
token = _Scanner.ScanLiteral(true, false, depth==0, false);
}
String str = _StringBuilder.ToString();
currToken.SetValue(_Scanner, str, start, _Scanner.CurrentPos - start);
}
private void IncrementAttributeToken ()
{
currentAttribute++;
if (attributeTokens.Length == currentAttribute) {
XmlAttributeTokenInfo [] newArray =
new XmlAttributeTokenInfo [attributeTokens.Length * 2];
attributeTokens.CopyTo (newArray, 0);
attributeTokens = newArray;
}
if (attributeTokens [currentAttribute] == null)
attributeTokens [currentAttribute] = new XmlAttributeTokenInfo (this);
currentAttributeToken = attributeTokens [currentAttribute];
currentAttributeToken.Clear ();
}
