public void WritesEnums()
{
var builder = new BufferBuilder();
builder.WriteEnum(TestEnum.One);
builder.WriteEnum<TestEnum, ushort>(TestEnum.Two);
builder.WriteEnum<TestEnum, int>(TestEnum.Four);
Assert.That(builder.ToArray(), new EqualConstraint(new[] {1, 2, 0, 4, 0, 0, 0}));
}
public void WritesSequentially()
{
var builder = new BufferBuilder();
builder.WriteByte(3);
builder.WriteString("ABC");
builder.WriteShort(2);
builder.WriteLong(8);
Assert.That(builder.ToArray(), new EqualConstraint(new[] {3, 65, 66, 67, 0, 2, 0, 8, 0, 0, 0}));
}
internal void StartAttribute( bool cacheAttrValue ) {
this.inAttribute = true;
this.cacheAttrValue = cacheAttrValue;
if ( cacheAttrValue ) {
if ( attrValue == null ) {
attrValue = new BufferBuilder();
}
else {
attrValue.Clear();
}
}
}
internal MailWriter(Stream stream, int lineLength)
{
this.bufferBuilder = new BufferBuilder();
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (lineLength < 0)
{
throw new ArgumentOutOfRangeException("lineLength");
}
this.stream = stream;
this.lineLength = lineLength;
this.onCloseHandler = new EventHandler(this.OnClose);
}
public void TestCombineBufferWithIds()
{
byte[] prefix = new byte[] { 1, 3, 5, 228, 113 };
int firstId = 12312345;
int secondId = 127;
byte[] suffix = new byte[] { 43, 31, 8 };
byte[] result = BufferBuilder.From(prefix).With(firstId).With(secondId).With(suffix).Create();
Assert.AreEqual(prefix.Length + suffix.Length + 8, result.Length);
Assert.IsTrue(Enumerable.SequenceEqual(prefix, result.Take(prefix.Length)));
Assert.IsTrue(Enumerable.SequenceEqual(BitConverter.GetBytes(firstId), result.Skip(prefix.Length).Take(4)));
Assert.IsTrue(Enumerable.SequenceEqual(BitConverter.GetBytes(secondId), result.Skip(prefix.Length + 4).Take(4)));
Assert.IsTrue(Enumerable.SequenceEqual(suffix, result.Skip(prefix.Length + 8)));
}
/// <summary>
/// No physics component.
/// </summary>
/// <param name="shape"></param>
/// <param name="effect"></param>
/// <returns></returns>
public static GameObject CreateRenderableGameObjectFromShape(ProceduralShape shape, Effect effect)
{
var ob = new GameObject();
ob.AddComponent(new RenderGeometryComponent(BufferBuilder.VertexBufferBuild(shape), BufferBuilder.IndexBufferBuild(shape), shape.PrimitiveCount));
if (shape is LineBatch)
{
ob.AddComponent(new LineRenderComponent(effect as BasicEffect));
}
ob.AddComponent(new EffectRenderComponent(effect));
return(ob);
}
public static Dictionary <string, object[]> Deserialize2(BufferBuilder bb)
{
Dictionary <string, object[]> valueDicts = new Dictionary <string, object[]>();
object[] rawDatas = null;
rawDatas = Deserialize2("LevelCfg", bb);
valueDicts.Add("LevelCfg", rawDatas);
rawDatas = Deserialize2("QuestionCfg", bb);
valueDicts.Add("QuestionCfg", rawDatas);
rawDatas = Deserialize2("GlobalConfig", bb);
valueDicts.Add("GlobalConfig", rawDatas);
rawDatas = Deserialize2("SelfTestCfg", bb);
valueDicts.Add("SelfTestCfg", rawDatas);
rawDatas = Deserialize2("SelfTestResultCfg", bb);
valueDicts.Add("SelfTestResultCfg", rawDatas);
return(valueDicts);
}
/// <summary>
/// Binary serialize
/// </summary>
/// <param name="stream">stream to write</param>
/// <param name="value">value to serialize</param>
public void BinarySerialize(ref BufferBuilder stream, ref List <T> value)
{
if (value.Count > 0)
{
stream.Write(BitConverter.GetBytes(value.Count));
var count = value.Count;
for (int i = 0; i < count; i++)
{
var obj = value[i];
typeGoInfo.BinarySerialize(ref stream, ref obj);
}
}
else
{
stream.Write(BitConverter.GetBytes(0));
}
}
public static string[] GetString1(BufferBuilder bb)
{
if (bb.GetNullFlag())
{
return(null);
}
else
{
int length = bb.Get7BitEncodeInt();
string[] value = new string[length];
for (int i = 0; i < length; i++)
{
value[i] = bb.GetString();
}
return(value);
}
}
public static QuestionCfg[] GetQuestionCfg1(BufferBuilder bb)
{
if (bb.GetNullFlag())
{
return(null);
}
else
{
int length = bb.Get7BitEncodeInt();
QuestionCfg[] value = new QuestionCfg[length];
for (int i = 0; i < length; i++)
{
value[i] = SerializeHelper.GetQuestionCfg(bb);
}
return(value);
}
}
public override void OnInitialise()
{
SystemCore.CursorVisible = false;
SystemCore.ActiveScene.SetUpBasicAmbientAndKey();
SystemCore.ActiveScene.SetDiffuseLightDir(0, new Vector3(1, 1, 1));
colorScheme = SystemCore.ActiveColorScheme;
SystemCore.ActiveScene.FogEnabled = false;
SystemCore.PhysicsSimulation.ForceUpdater.Gravity = new BEPUutilities.Vector3(0, -9.81f, 0);
mouseCamera = new MouseFreeCamera(new Vector3(10, 10, 10));
SystemCore.SetActiveCamera(mouseCamera);
var effect = EffectLoader.LoadSM5Effect("FlatShaded");
//ground plane
var groundShape = new ProceduralCuboid(100, 100, 0.5f);
groundShape.SetColor(colorScheme.Color5);
var gameObjectPlane = new GameObject();
gameObjectPlane.AddComponent(new RenderGeometryComponent(BufferBuilder.VertexBufferBuild(groundShape), BufferBuilder.IndexBufferBuild(groundShape), groundShape.PrimitiveCount));
gameObjectPlane.AddComponent(new EffectRenderComponent(effect));
var groundPhysicsComponent = new PhysicsComponent(false, true, PhysicsMeshType.box);
gameObjectPlane.AddComponent(groundPhysicsComponent);
SystemCore.GameObjectManager.AddAndInitialiseGameObject(gameObjectPlane);
groundPhysicsComponent.PhysicsEntity.IsAffectedByGravity = false;
var shape = new ProceduralCube();
shape.SetColor(colorScheme.Color4);
for (int i = 0; i < 100; i++)
{
AddCube(shape, effect, RandomHelper.GetRandomVector3(new Vector3(-10, 2, -10), new Vector3(10, 20, 10)));
}
AddInputBindings();
base.OnInitialise();
}
public void StatsBufferize()
{
var handler = new BufferBuilderHandlerMock();
var bufferBuilder = new BufferBuilder(handler, 3, "\n");
using (var statsBufferize = new StatsBufferize(new Telemetry(), bufferBuilder, 10, null, TimeSpan.Zero))
{
statsBufferize.Send("1");
while (handler.Buffer == null)
{
Task.Delay(TimeSpan.FromMilliseconds(1)).Wait();
}
// Sent because buffer is full.
Assert.AreEqual("1", Encoding.UTF8.GetString(handler.Buffer));
}
}
private StatsBufferize CreateStatsBufferize(
Telemetry telemetry,
ITransport transport,
int bufferCapacity,
AdvancedStatsConfig config)
{
var bufferHandler = new BufferBuilderHandler(telemetry, transport);
var bufferBuilder = new BufferBuilder(bufferHandler, bufferCapacity, "\n");
var statsBufferize = _factory.CreateStatsBufferize(
bufferBuilder,
config.MaxMetricsInAsyncQueue,
config.MaxBlockDuration,
config.DurationBeforeSendingNotFullBuffer);
return(statsBufferize);
}
public static GlobalConfig[] GetGlobalConfig1(BufferBuilder bb)
{
if (bb.GetNullFlag())
{
return(null);
}
else
{
int length = bb.Get7BitEncodeInt();
GlobalConfig[] value = new GlobalConfig[length];
for (int i = 0; i < length; i++)
{
value[i] = SerializeHelper.GetGlobalConfig(bb);
}
return(value);
}
}
private Pop3Command(SecureString password)
{
this.type = Pop3CommandType.Pass;
BufferBuilder bufferBuilder = new BufferBuilder(Pop3Command.PassBytes.Length + password.Length + Pop3Command.CrLfBytes.Length);
bufferBuilder.Append(Pop3Command.PassBytes);
try
{
bufferBuilder.Append(password);
}
catch (ArgumentException innerException)
{
throw new Pop3InvalidCommandException("All characters in the string must be in the range 0x00 - 0xff.", innerException);
}
bufferBuilder.Append(Pop3Command.CrLfBytes);
this.commandBytes = bufferBuilder.GetBuffer();
}
public static Dictionary <string, Dictionary <int, object> > Deserialize(BufferBuilder bb)
{
Dictionary <string, Dictionary <int, object> > valueDicts = new Dictionary <string, Dictionary <int, object> >();
Dictionary <int, object> valueDict;
valueDict = Deserialize("LevelCfg", bb);
valueDicts.Add("LevelCfg", valueDict);
valueDict = Deserialize("QuestionCfg", bb);
valueDicts.Add("QuestionCfg", valueDict);
valueDict = Deserialize("GlobalConfig", bb);
valueDicts.Add("GlobalConfig", valueDict);
valueDict = Deserialize("SelfTestCfg", bb);
valueDicts.Add("SelfTestCfg", valueDict);
valueDict = Deserialize("SelfTestResultCfg", bb);
valueDicts.Add("SelfTestResultCfg", valueDict);
return(valueDicts);
}
public Exporter()
{
Gltf = new Types.Gltf();
Cache = new ResourcesCache <string>();
BufferBuilder = new BufferBuilder();
Nodes = new NodeExporter(this);
Meshes = new MeshExporter(this);
Materials = new MaterialExporter(this);
Textures = new TextureExporter(this);
Images = new ImageExporter(this);
// Asset
Gltf.Asset = new Types.Asset
{
Version = "2.0", // glTF 2.0
};
}
private void SendMetric(string metricName, int value)
{
if (_optionalTransport != null && _optionalMetricSerializer != null)
{
var serializedMetric = new SerializedMetric();
var metricStats = new StatsMetric
{
MetricType = MetricType.Count,
StatName = metricName,
NumericValue = value,
SampleRate = 1.0,
Tags = _optionalTags,
};
_optionalMetricSerializer.SerializeTo(ref metricStats, serializedMetric);
var bytes = BufferBuilder.GetBytes(serializedMetric.ToString());
_optionalTransport.Send(bytes, bytes.Length);
}
}
public Projectile(Vector3 position, Vector3 velocity, Weapon firingWeapon)
{
ProceduralSphereTwo projectileShape = new ProceduralSphereTwo(10);
projectileShape.Scale(0.05f);
AddComponent(new RenderGeometryComponent(BufferBuilder.VertexBufferBuild(projectileShape),
BufferBuilder.IndexBufferBuild(projectileShape), projectileShape.PrimitiveCount));
AddComponent(new EffectRenderComponent(EffectLoader.LoadSM5Effect("flatshaded")));
AddComponent(new PhysicsComponent(true, false, PhysicsMeshType.sphere));
AddComponent(new ProjectileComponent(firingWeapon));
SystemCore.GameObjectManager.AddAndInitialiseGameObject(this);
Transform.SetPosition(position);
Transform.Velocity = velocity;
}
/// <summary>
/// Returns a vector of feature contributions for a given example.
/// <paramref name="builder"/> is used as a buffer to accumulate the contributions across trees.
/// If <paramref name="builder"/> is null, it will be created, otherwise it will be reused.
/// </summary>
internal void GetFeatureContributions(ref VBuffer <float> features, ref VBuffer <float> contribs, ref BufferBuilder <float> builder)
{
// The feature contributions are equal to the sum of per-tree contributions.
// REVIEW: it might make sense to accumulate as doubles.
if (builder == null)
{
builder = new BufferBuilder <float>(R4Adder.Instance);
}
builder.Reset(features.Length, false);
foreach (var tree in _trees)
{
tree.AppendFeatureContributions(ref features, builder);
}
builder.GetResult(ref contribs);
}
/// <summary>
/// Binary serialize
/// </summary>
/// <param name="stream">stream to write</param>
/// <param name="data">value to serialize</param>
public void BinarySerialize(ref BufferBuilder stream, ref TObject data)
{
if (data == null)
{
//flag this object is null
stream.Write(0);
}
else
{
//flag this object is not null
stream.Write(1);
for (int i = 0; i < PropertiesLength; i++)
{
//var value = property.InternalGetValue(ref data);
Properties[i].BinarySerialize(ref stream, ref data);
}
}
}
public static void SerializePrimitive(BufferBuilder bb, object value, string typeName)
{
if (Array.IndexOf(CodeGenConstants.BaseType, typeName) != -1)
{
string methodName = "Put" + typeName.UppercaseFirst();
Type type = bb.GetType();
BindingFlags bf = BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly;
MethodInfo method = type.GetMethod(methodName, bf);
method.Invoke(bb, new object[] { value });
}
else if (value is IByteEncode)
{
if (!bb.PutNullFlag(value))
{
(value as IByteEncode).Encode(bb);
}
}
}
protected override void Initialise()
{
ProceduralSphereTwo playerShape = new ProceduralSphereTwo(10);
playerShape.Scale(2f);
AddComponent(new RenderGeometryComponent(BufferBuilder.VertexBufferBuild(playerShape),
BufferBuilder.IndexBufferBuild(playerShape), playerShape.PrimitiveCount));
AddComponent(new EffectRenderComponent(EffectLoader.LoadSM5Effect("flatshaded")));
AddComponent(new PhysicsComponent(true, false, PhysicsMeshType.sphere));
AddComponent(new SimpleEnemyAIController());
Name = "simpleenemy";
SystemCore.GameObjectManager.AddAndInitialiseGameObject(this);
physicsComponent = GetComponent <PhysicsComponent>();
}
public async Task Convert(BufferBuilder builder, MapDocument document, IMapObject obj, ResourceCollector resourceCollector)
{
var entity = (Entity)obj;
var tc = await document.Environment.GetTextureCollection();
var sd = GetSpriteData(entity);
if (sd == null || !sd.ContentsReplaced)
{
return;
}
var name = sd.Name;
var scale = sd.Scale;
var width = entity.BoundingBox.Width;
var height = entity.BoundingBox.Height;
var t = await tc.GetTextureItem(name);
var texture = $"{document.Environment.ID}::{name}";
if (t != null)
{
resourceCollector.RequireTexture(t.Name);
}
var tint = sd.Color.ToVector4();
var flags = VertexFlags.None;
if (entity.IsSelected)
{
flags |= VertexFlags.SelectiveTransformed;
}
builder.Append(
new [] { new VertexStandard {
Position = entity.Origin, Normal = new Vector3(width, height, 0), Colour = Vector4.One, Tint = tint, Flags = flags
} },
new [] { 0u },
new [] { new BufferGroup(PipelineType.BillboardAlpha, CameraType.Perspective, entity.BoundingBox.Center, texture, 0, 1) }
);
}
public void BuildTest()
{
var bufferBuilder = new BufferBuilder();
var view0 = new ArraySegment <byte>(new byte[] { 0x00, 0x01, 0x02 });
var view0Index = bufferBuilder.AddView(view0, 4, Types.BufferView.TargetEnum.ELEMENT_ARRAY_BUFFER);
var view1 = new ArraySegment <byte>(new byte[] { 0x10, 0x11 });
var view1Index = bufferBuilder.AddView(view1);
var view2 = new ArraySegment <byte>(new byte[] { 0x20, 0x21, 0x22, 0x23 });
var view2Index = bufferBuilder.AddView(view2);
List <Types.BufferView> views;
var bufferBytes = bufferBuilder.BuildBytes(out views);
Assert.AreEqual(12, bufferBytes.Length); // Actual size is 5Bytes, but aligned to 4Bytes.
Assert.That(bufferBytes, Is.EquivalentTo(new byte[] {
0x00, 0x01, 0x02, /* Align */ 0x00,
0x10, 0x11, /* Align */ 0x00, 0x00,
0x20, 0x21, 0x22, 0x23
}));
Assert.AreEqual(3, views.Count);
Assert.AreEqual(0, views[0].Buffer);
Assert.AreEqual(0, views[0].ByteOffset);
Assert.AreEqual(3, views[0].ByteLength);
Assert.AreEqual(4, views[0].ByteStride);
Assert.AreEqual(Types.BufferView.TargetEnum.ELEMENT_ARRAY_BUFFER, views[0].Target);
Assert.AreEqual(0, views[1].Buffer);
Assert.AreEqual(4, views[1].ByteOffset);
Assert.AreEqual(2, views[1].ByteLength);
Assert.AreEqual(null, views[1].ByteStride);
Assert.AreEqual(null, views[1].Target);
Assert.AreEqual(0, views[2].Buffer);
Assert.AreEqual(8, views[2].ByteOffset);
Assert.AreEqual(4, views[2].ByteLength);
Assert.AreEqual(null, views[2].ByteStride);
Assert.AreEqual(null, views[2].Target);
}
public static IPoint Calculate(IGeometry geom)
{
double bufferAmt = -0.001, inc = -.0002, stopper = 0;
IGeometry prevBuffer = null, buffer = geom;
BufferBuilder bldr = new BufferBuilder();
bldr.EndCapStyle = BufferStyle.CapRound;
while (!IsAllCW(buffer))
{
buffer = bldr.Buffer(geom, bufferAmt);
if (stopper++ > 300)
{
break;
}
prevBuffer = buffer;
bufferAmt += inc;
}
IPoint labelPoint;
if (buffer is IGeometryCollection) // It is empty.
{
labelPoint = GetPoint(prevBuffer);
}
else
{
labelPoint = GetPoint(buffer);
}
// Should never happen but just in case we need to have some point.
if (labelPoint == null)
{
return(geom.Centroid);
}
else
{
return(labelPoint);
}
}
// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skin
int ExportInverseBindMatrices(Matrix4x4[] matrices)
{
matrices = matrices.Select(CoordUtils.ConvertSpace).ToArray();
// MAT4! | FLOAT!
byte[] buffer = PrimitiveExporter.Marshal(matrices);
var viewIndex = BufferBuilder.AddView(new ArraySegment <byte>(buffer));
var accessor = new Types.Accessor
{
BufferView = viewIndex,
ByteOffset = 0,
ComponentType = Types.Accessor.ComponentTypeEnum.FLOAT,
Count = matrices.Length,
Type = Types.Accessor.TypeEnum.Mat4,
};
return(Types.GltfExtensions.AddAccessor(Gltf, accessor));
}
public static void SerializeDictionary(BufferBuilder bb, object value, string typeName)
{
IDictionary dictionary = value as IDictionary;
string[] genericTypes = CodeExporterHelper.GetDictionaryGenericTypeName(typeName);
if (!bb.PutNullFlag(value))
{
int length = dictionary.Count;
bb.Put7BitEncodeInt(length);
if (length != 0)
{
foreach (var key in dictionary.Keys)
{
SerializeObject(bb, key, genericTypes[0]);
SerializeObject(bb, dictionary[key], genericTypes[1]);
}
}
}
}
public async Task StatsBufferize()
{
var handler = new BufferBuilderHandlerMock();
var bufferBuilder = new BufferBuilder(handler, 3, "\n");
var timeout = TimeSpan.FromMilliseconds(300);
var statsBufferize = new StatsBufferize(bufferBuilder, 10, null, timeout);
statsBufferize.Send("123");
statsBufferize.Send("4");
await Task.Delay(timeout.Multiply(0.5));
// Sent because buffer is full.
Assert.AreEqual(Encoding.UTF8.GetBytes("123"), handler.Buffer);
// Sent because we wait more than the timeout.
await Task.Delay(timeout.Multiply(2));
Assert.AreEqual(Encoding.UTF8.GetBytes("4"), handler.Buffer);
}
int ExportTangents(Vector4[] vec4)
{
vec4 = vec4.Select(CoordUtils.ConvertSpace).ToArray();
// VEC4! | FLOAT!
byte[] buffer = PrimitiveExporter.Marshal(vec4);
var viewIndex = BufferBuilder.AddView(new ArraySegment <byte>(buffer));
var accessor = new Types.Accessor
{
BufferView = viewIndex,
ByteOffset = 0,
ComponentType = Types.Accessor.ComponentTypeEnum.FLOAT,
Count = vec4.Length,
Type = Types.Accessor.TypeEnum.Vec4,
};
return(Types.GltfExtensions.AddAccessor(Gltf, accessor));
}
public void ShouldResizeWhenBufferJustDoesNotFit()
{
const int bufferLength = 128;
byte[] buffer = new byte[bufferLength + 1];
Arrays.Fill(buffer, (byte)7);
UnsafeBuffer srcBuffer = new UnsafeBuffer(buffer);
BufferBuilder bufferBuilder = new BufferBuilder(bufferLength);
bufferBuilder.Append(srcBuffer, 0, buffer.Length);
byte[] temp = new byte[buffer.Length];
bufferBuilder.Buffer().GetBytes(0, temp, 0, buffer.Length);
Assert.That(bufferBuilder.Limit(), Is.EqualTo(buffer.Length));
Assert.That(bufferBuilder.Capacity(), Is.GreaterThan(bufferLength));
Assert.That(temp, Is.EqualTo(buffer));
}
int ExportWeights(Vector4[] weights)
{
// VEC4! | FLOAT!
// | UNSIGNED_BYTE (normalized)
// | UNSIGNED_SHORT (normalized)
byte[] buffer = PrimitiveExporter.Marshal(weights);
var viewIndex = BufferBuilder.AddView(new ArraySegment <byte>(buffer));
var accessor = new Types.Accessor
{
BufferView = viewIndex,
ByteOffset = 0,
ComponentType = Types.Accessor.ComponentTypeEnum.FLOAT,
Count = weights.Length,
Type = Types.Accessor.TypeEnum.Vec4,
};
return(Types.GltfExtensions.AddAccessor(Gltf, accessor));
}
private void BufferOriginalPrecision()
{
try
{
// use fast noding by default
BufferBuilder bufBuilder = new BufferBuilder();
bufBuilder.QuadrantSegments = m_nQuadrantSegments;
bufBuilder.EndCapStyle = m_enumEndCapStyle;
m_objResultGeometry = bufBuilder.Buffer(m_objTargetGeometry, m_dDistance);
}
catch (Exception ex)
{
saveException = ex;
// don't propagate the exception - it will be detected by
// fact that m_objResultGeometry is null
ExceptionManager.Publish(ex);
}
}
public void ShouldFillBufferWithoutResizing()
{
const int bufferLength = 128;
byte[] buffer = new byte[bufferLength];
Arrays.Fill(buffer, (byte)7);
UnsafeBuffer srcBuffer = new UnsafeBuffer(buffer);
BufferBuilder bufferBuilder = new BufferBuilder(bufferLength);
bufferBuilder.Append(srcBuffer, 0, bufferLength);
byte[] temp = new byte[bufferLength];
bufferBuilder.Buffer().GetBytes(0, temp, 0, bufferLength);
Assert.That(bufferBuilder.Limit(), Is.EqualTo(bufferLength));
Assert.That(bufferBuilder.Capacity(), Is.EqualTo(bufferLength));
Assert.That(temp, Is.EqualTo(buffer));
}
internal int DtdParserProxy_ParseNamedCharRef( bool expand, BufferBuilder internalSubsetBuilder ) {
return this.ParseNamedCharRef( expand, internalSubsetBuilder );
}
internal DtdParser( IDtdParserAdapter readerAdapter ) {
Debug.Assert( readerAdapter != null );
this.readerAdapter = readerAdapter;
nameTable = readerAdapter.NameTable;
validate = readerAdapter.DtdValidation;
normalize = readerAdapter.Normalization;
supportNamespaces = readerAdapter.Namespaces;
v1Compat = readerAdapter.V1CompatibilityMode;
schemaInfo = new SchemaInfo();
schemaInfo.SchemaType = SchemaType.DTD;
stringBuilder = new BufferBuilder();
Uri baseUri = readerAdapter.BaseUri;
if ( baseUri != null ) {
documentBaseUri = baseUri.ToString();
}
}
private void ParseSubset() {
int startTagEntityId;
for (;;) {
Token token = GetToken( false );
startTagEntityId = currentEntityId;
switch ( token ) {
case Token.AttlistDecl:
ParseAttlistDecl();
break;
case Token.ElementDecl:
ParseElementDecl();
break;
case Token.EntityDecl:
ParseEntityDecl();
break;
case Token.NotationDecl:
ParseNotationDecl();
break;
case Token.Comment:
ParseComment();
break;
case Token.PI:
ParsePI();
break;
case Token.CondSectionStart:
if ( ParsingInternalSubset ) {
Throw( curPos - 3, Res.Xml_InvalidConditionalSection ); // 3==strlen("<![")
}
ParseCondSection();
startTagEntityId = currentEntityId;
break;
case Token.CondSectionEnd:
if ( condSectionDepth > 0 ) {
condSectionDepth--;
if ( validate && currentEntityId != condSectionEntityIds[condSectionDepth] ) {
SendValidationEvent( curPos, XmlSeverityType.Error, Res.Sch_ParEntityRefNesting, string.Empty );
}
}
else {
Throw( curPos - 3, Res.Xml_UnexpectedCDataEnd );
}
break;
case Token.RightBracket:
if ( ParsingInternalSubset ) {
if ( condSectionDepth != 0 ) {
Throw( curPos, Res.Xml_UnclosedConditionalSection );
}
// append the rest to internal subset value but not the closing ']'
if ( internalSubsetValueSb != null ) {
Debug.Assert( curPos > 0 && chars[curPos-1] == ']' );
SaveParsingBuffer( curPos - 1 );
internalSubsetValue = internalSubsetValueSb.ToString();
internalSubsetValueSb = null;
}
// check '>'
if ( GetToken( false ) != Token.GreaterThan ) {
ThrowUnexpectedToken( curPos, ">" );
}
#if DEBUG
// check entity nesting
Debug.Assert( readerAdapter.EntityStackLength == 0 ||
( freeFloatingDtd && readerAdapter.EntityStackLength == 1 ) );
#endif
}
else {
Throw( curPos, Res.Xml_ExpectDtdMarkup );
}
return;
case Token.Eof:
if ( ParsingInternalSubset && !freeFloatingDtd ) {
Throw( curPos, Res.Xml_IncompleteDtdContent );
}
if ( condSectionDepth != 0 ) {
Throw( curPos, Res.Xml_UnclosedConditionalSection );
}
return;
default:
Debug.Assert( false );
break;
}
Debug.Assert( scanningFunction == ScanningFunction.SubsetContent );
if ( currentEntityId != startTagEntityId ) {
if ( validate ) {
SendValidationEvent( curPos, XmlSeverityType.Error, Res.Sch_ParEntityRefNesting, string.Empty );
}
else {
if ( !v1Compat ) {
Throw( curPos, Res.Sch_ParEntityRefNesting );
}
}
}
}
}
public void WritesString()
{
var builder = new BufferBuilder();
builder.WriteString("ABC");
Assert.That(builder.ToArray(), new EqualConstraint(new[] {65, 66, 67, 0}));
}
void IDtdParserAdapter.ParseComment( BufferBuilder sb ) {
reader.DtdParserProxy_ParseComment( sb );
}
private int EatWhitespaces( BufferBuilder sb ) {
int pos = ps.charPos;
int wsCount = 0;
char[] chars = ps.chars;
for (;;) {
for (;;) {
switch ( chars[pos] ) {
case (char)0xA:
pos++;
OnNewLine( pos );
continue;
case (char)0xD:
if ( chars[pos+1] == (char)0xA ) {
int tmp1 = pos - ps.charPos;
if ( sb != null && !ps.eolNormalized ) {
if ( tmp1 > 0 ) {
sb.Append( chars, ps.charPos, tmp1 );
wsCount += tmp1;
}
ps.charPos = pos + 1;
}
pos += 2;
}
else if ( pos+1 < ps.charsUsed || ps.isEof ) {
if ( !ps.eolNormalized ) {
chars[pos] = (char)0xA; // EOL normalization of 0xD
}
pos++;
}
else {
goto ReadData;
}
OnNewLine( pos );
continue;
case (char)0x9:
case (char)0x20:
pos++;
continue;
default:
if ( pos == ps.charsUsed ) {
goto ReadData;
}
else {
int tmp2 = pos - ps.charPos;
if ( tmp2 > 0 ) {
if ( sb != null ) {
sb.Append( ps.chars, ps.charPos, tmp2 );
}
ps.charPos = pos;
wsCount += tmp2;
}
return wsCount;
}
}
}
ReadData:
int tmp3 = pos - ps.charPos;
if ( tmp3 > 0 ) {
if ( sb != null ) {
sb.Append( ps.chars, ps.charPos, tmp3 );
}
ps.charPos = pos;
wsCount += tmp3;
}
if ( ReadData() == 0 ) {
if ( ps.charsUsed - ps.charPos == 0 ) {
return wsCount;
}
if ( ps.chars[ps.charPos] != (char)0xD ) {
Debug.Assert( false, "We should never get to this point." );
Throw( Res.Xml_UnexpectedEOF1 );
}
Debug.Assert( ps.isEof );
}
pos = ps.charPos;
chars = ps.chars;
}
}
public void WritesShort()
{
var builder = new BufferBuilder();
builder.WriteShort(513);
Assert.That(builder.ToArray(), new EqualConstraint(new[] { 1, 2 }));
}
// This constructor is used when creating XmlTextReaderImpl reader via "XmlReader.Create(..)"
private XmlTextReaderImpl( XmlResolver resolver, XmlReaderSettings settings, XmlParserContext context ) {
v1Compat = false;
outerReader = this;
xmlContext = new XmlContext();
// create or get nametable and namespace manager from XmlParserContext
XmlNameTable nt = settings.NameTable;
if ( context == null ) {
if ( nt == null ) {
nt = new NameTable();
Debug.Assert( nameTableFromSettings == false );
}
else {
nameTableFromSettings = true;
}
nameTable = nt;
namespaceManager = new XmlNamespaceManager( nt );
}
else {
SetupFromParserContext( context, settings );
nt = nameTable;
}
nt.Add( string.Empty );
Xml = nt.Add( "xml" );
XmlNs = nt.Add( "xmlns" );
xmlResolver = resolver;
Debug.Assert( index == 0 );
nodes = new NodeData[ NodesInitialSize ];
nodes[0] = new NodeData();
curNode = nodes[0];
stringBuilder = new BufferBuilder();
entityHandling = EntityHandling.ExpandEntities;
whitespaceHandling = ( settings.IgnoreWhitespace ) ? WhitespaceHandling.Significant : WhitespaceHandling.All;
normalize = true;
ignorePIs = settings.IgnoreProcessingInstructions;
ignoreComments = settings.IgnoreComments;
checkCharacters = settings.CheckCharacters;
lineNumberOffset = settings.LineNumberOffset;
linePositionOffset = settings.LinePositionOffset;
ps.lineNo = lineNumberOffset + 1;
ps.lineStartPos = - linePositionOffset - 1;
curNode.SetLineInfo( ps.LineNo - 1, ps.LinePos - 1 );
prohibitDtd = settings.ProhibitDtd;
fragmentParserContext = context;
parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
nextParsingFunction = ParsingFunction.DocumentContent;
switch ( settings.ConformanceLevel ) {
case ConformanceLevel.Auto:
fragmentType = XmlNodeType.None;
fragment = true;
break;
case ConformanceLevel.Fragment:
fragmentType = XmlNodeType.Element;
fragment = true;
break;
case ConformanceLevel.Document:
fragmentType = XmlNodeType.Document;
break;
default:
Debug.Assert( false );
goto case ConformanceLevel.Document;
}
}
// Parses processing instruction; if piInDtdStringBuilder != null, the processing instruction is in DTD and
// it will be saved in the passed string builder (target, whitespace & value).
private bool ParsePI( BufferBuilder piInDtdStringBuilder ) {
if ( parsingMode == ParsingMode.Full ) {
curNode.SetLineInfo( ps.LineNo, ps.LinePos );
}
Debug.Assert( stringBuilder.Length == 0 );
// parse target name
int nameEndPos = ParseName();
string target = nameTable.Add( ps.chars, ps.charPos, nameEndPos - ps.charPos );
if ( string.Compare( target, "xml", StringComparison.OrdinalIgnoreCase ) == 0 ) {
Throw( target.Equals( "xml" ) ? Res.Xml_XmlDeclNotFirst : Res.Xml_InvalidPIName, target );
}
ps.charPos = nameEndPos;
if ( piInDtdStringBuilder == null ) {
if ( !ignorePIs && parsingMode == ParsingMode.Full ) {
curNode.SetNamedNode( XmlNodeType.ProcessingInstruction, target );
}
}
else {
piInDtdStringBuilder.Append( target );
}
// check mandatory whitespace
char ch = ps.chars[ps.charPos];
Debug.Assert( ps.charPos < ps.charsUsed );
if ( EatWhitespaces( piInDtdStringBuilder ) == 0 ) {
if ( ps.charsUsed - ps.charPos < 2 ) {
ReadData();
}
if ( ch != '?' || ps.chars[ps.charPos+1] != '>' ) {
Throw( Res.Xml_BadNameChar, XmlException.BuildCharExceptionStr( ch ) );
}
}
// scan processing instruction value
int startPos, endPos;
if ( ParsePIValue( out startPos, out endPos ) ) {
if ( piInDtdStringBuilder == null ) {
if ( ignorePIs ) {
return false;
}
if ( parsingMode == ParsingMode.Full ) {
curNode.SetValue( ps.chars, startPos, endPos - startPos );
}
}
else {
piInDtdStringBuilder.Append( ps.chars, startPos, endPos - startPos );
}
}
else {
BufferBuilder sb;
if ( piInDtdStringBuilder == null ) {
if ( ignorePIs || parsingMode != ParsingMode.Full ) {
while ( !ParsePIValue( out startPos, out endPos ) );
return false;
}
sb = stringBuilder;
Debug.Assert( stringBuilder.Length == 0 );
}
else {
sb = piInDtdStringBuilder;
}
do {
sb.Append( ps.chars, startPos, endPos - startPos );
} while ( !ParsePIValue( out startPos, out endPos ) );
sb.Append( ps.chars, startPos, endPos - startPos );
if ( piInDtdStringBuilder == null ) {
curNode.SetValue( stringBuilder.ToString() );
stringBuilder.Length = 0;
}
}
return true;
}
// Initializes a new instance of the XmlTextReaderImpl class with the specified XmlNameTable.
// This constructor is used when creating XmlTextReaderImpl for V1 XmlTextReader
internal XmlTextReaderImpl( XmlNameTable nt ) {
Debug.Assert( nt != null );
v1Compat = true;
outerReader = this;
nameTable = nt;
nt.Add( string.Empty );
xmlResolver = new XmlUrlResolver();
Xml = nt.Add( "xml" );
XmlNs = nt.Add( "xmlns" );
Debug.Assert( index == 0 );
nodes = new NodeData[ NodesInitialSize ];
nodes[0] = new NodeData();
curNode = nodes[0];
stringBuilder = new BufferBuilder();
xmlContext = new XmlContext();
parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
nextParsingFunction = ParsingFunction.DocumentContent;
entityHandling = EntityHandling.ExpandCharEntities;
whitespaceHandling = WhitespaceHandling.All;
closeInput = true;
ps.lineNo = 1;
ps.lineStartPos = -1;
}
internal void DtdParserProxy_ParseComment( BufferBuilder sb ) {
Debug.Assert( parsingMode == ParsingMode.Full );
try {
if ( sb == null ) {
ParsingMode savedParsingMode = parsingMode;
parsingMode = ParsingMode.SkipNode;
ParseCDataOrComment( XmlNodeType.Comment );
parsingMode = savedParsingMode;
}
else {
NodeData originalCurNode = curNode;
curNode = AddNode( index + attrCount + 1, index );
ParseCDataOrComment( XmlNodeType.Comment );
curNode.CopyTo( sb );
curNode = originalCurNode;
}
}
catch ( XmlException e ) {
if ( e.ResString == Res.Xml_UnexpectedEOF && ps.entity != null ) {
SendValidationEvent( XmlSeverityType.Error, Res.Sch_ParEntityRefNesting, null, ps.LineNo, ps.LinePos );
}
else {
throw;
}
}
}
internal void DtdParserProxy_ParsePI( BufferBuilder sb ) {
if ( sb == null ) {
ParsingMode pm = parsingMode;
parsingMode = ParsingMode.SkipNode;
ParsePI( null );
parsingMode = pm;
}
else {
ParsePI( sb );
}
}
public void WritesChar()
{
var builder = new BufferBuilder();
builder.WriteChar('A');
Assert.That(builder.ToArray(), new EqualConstraint(new[] { 65 }));
}
// Parses numeric character entity reference (e.g.    ).
// - replaces the last one or two character of the entity reference (';' and the character before) with the referenced
// character or surrogates pair (if expand == true)
// - returns position of the end of the character reference, that is of the character next to the original ';'
// - if (expand == true) then ps.charPos is changed to point to the replaced character
private int ParseNumericCharRef( bool expand, BufferBuilder internalSubsetBuilder, out EntityType entityType ) {
for (;;) {
int newPos;
int charCount;
switch ( newPos = ParseNumericCharRefInline( ps.charPos, expand, internalSubsetBuilder, out charCount, out entityType ) ) {
case -2:
// read new characters in the buffer
if ( ReadData() == 0 ) {
Throw( Res.Xml_UnexpectedEOF );
}
Debug.Assert( ps.chars[ps.charPos] == '&' );
continue;
default:
if ( expand ) {
ps.charPos = newPos - charCount;
}
return newPos;
}
}
}
public void WritesUtf8Char()
{
var builder = new BufferBuilder();
builder.WriteChar('猫');
Assert.That(builder.ToArray(), new EqualConstraint(new[] { 0xE7, 0x8C, 0xAB }));
}
// Parses numeric character entity reference (e.g.    ).
// Returns -2 if more data is needed in the buffer
// Otherwise
// - replaces the last one or two character of the entity reference (';' and the character before) with the referenced
// character or surrogates pair (if expand == true)
// - returns position of the end of the character reference, that is of the character next to the original ';'
private int ParseNumericCharRefInline( int startPos, bool expand, BufferBuilder internalSubsetBuilder, out int charCount, out EntityType entityType ) {
Debug.Assert( ps.chars[startPos] == '&' && ps.chars[startPos + 1] == '#' );
int val;
int pos;
char[] chars;
val = 0;
string badDigitExceptionString = null;
chars = ps.chars;
pos = startPos + 2;
charCount = 0;
if ( chars[pos] == 'x' ) {
pos++;
badDigitExceptionString = Res.Xml_BadHexEntity;
for (;;) {
char ch = chars[pos];
if ( ch >= '0' && ch <= '9' )
val = val * 16 + ch - '0';
else if ( ch >= 'a' && ch <= 'f' )
val = val * 16 + 10 + ch - 'a';
else if ( ch >= 'A' && ch <= 'F' )
val = val * 16 + 10 + ch - 'A';
else
break;
pos++;
}
entityType = EntityType.CharacterHex;
}
else if ( pos < ps.charsUsed ) {
badDigitExceptionString = Res.Xml_BadDecimalEntity;
while ( chars[pos] >= '0' && chars[pos] <= '9' ) {
val = val * 10 + chars[pos] - '0';
pos++;
}
entityType = EntityType.CharacterDec;
}
else {
// need more data in the buffer
entityType = EntityType.Unexpanded;
return -2;
}
if ( chars[pos] != ';' ) {
if ( pos == ps.charsUsed ) {
// need more data in the buffer
return -2;
}
else {
Throw( pos, badDigitExceptionString );
}
}
// simple character
if ( val <= char.MaxValue ) {
char ch = (char)val;
if ( ( !xmlCharType.IsCharData(ch) || ( ch >= SurLowStart && ch <= 0xdeff ) ) &&
( ( v1Compat && normalize ) || (!v1Compat && checkCharacters ) ) ) {
ThrowInvalidChar( (ps.chars[ps.charPos + 2] == 'x') ? ps.charPos + 3 : ps.charPos + 2, ch );
}
if ( expand ) {
if ( internalSubsetBuilder != null ) {
internalSubsetBuilder.Append( ps.chars, ps.charPos, pos - ps.charPos + 1 );
}
chars[pos] = ch;
}
charCount = 1;
return pos + 1;
}
// surrogate
else {
int v = val - 0x10000;
int low = SurLowStart + v % 1024;
int high = SurHighStart + v / 1024;
if ( normalize ) {
char ch = (char)high;
if ( ch >= SurHighStart && ch <= SurHighEnd ) {
ch = (char)low;
if ( ch >=SurLowStart && ch <= SurLowEnd ) {
goto Return;
}
}
ThrowInvalidChar( (ps.chars[ps.charPos + 2] == 'x') ? ps.charPos + 3 : ps.charPos + 2, (char)val );
}
Return:
Debug.Assert( pos > 0 );
if ( expand ) {
if ( internalSubsetBuilder != null ) {
internalSubsetBuilder.Append( ps.chars, ps.charPos, pos - ps.charPos + 1 );
}
chars[pos-1] = (char)high;
chars[pos] = (char)low;
}
charCount = 2;
return pos + 1;
}
}
public void WritesLong()
{
var builder = new BufferBuilder();
builder.WriteLong(0x0FEDBEEF);
Assert.That(builder.ToArray(), new EqualConstraint(new[] {0xEF, 0xBE, 0xED, 0x0F}));
}
// Parses named character entity reference (& ' < > ").
// Returns -1 if the reference is not a character entity reference.
// Otherwise
// - replaces the last character of the entity reference (';') with the referenced character (if expand == true)
// - returns position of the end of the character reference, that is of the character next to the original ';'
// - if (expand == true) then ps.charPos is changed to point to the replaced character
private int ParseNamedCharRef( bool expand, BufferBuilder internalSubsetBuilder ) {
for (;;) {
int newPos;
switch ( newPos = ParseNamedCharRefInline( ps.charPos, expand, internalSubsetBuilder ) ) {
case -1:
return -1;
case -2:
// read new characters in the buffer
if ( ReadData() == 0 ) {
return -1;
}
Debug.Assert( ps.chars[ps.charPos] == '&' );
continue;
default:
if ( expand ) {
ps.charPos = newPos - 1;
}
return newPos;
}
}
}
// This constructor is used when creating XmlTextReader reader via "XmlReader.Create(..)"
private XmlTextReader(XmlReaderSettings settings)
{
xmlContext = new XmlContext();
// create nametable
XmlNameTable nt = settings.NameTable;
if (nt == null)
{
nt = new NameTable();
Debug.Assert(nameTableFromSettings == false);
}
else
{
nameTableFromSettings = true;
}
nameTable = nt;
nt.Add("");
Xml = nt.Add("xml");
XmlNs = nt.Add("xmlns");
Debug.Assert(index == 0);
nodes = new NodeData[NodesInitialSize];
nodes[0] = new NodeData();
curNode = nodes[0];
stringBuilder = new BufferBuilder();
entityHandling = EntityHandling.ExpandEntities;
whitespaceHandling = (settings.IgnoreWhitespace) ? WhitespaceHandling.Significant : WhitespaceHandling.All;
normalize = true;
ignorePIs = settings.IgnoreProcessingInstructions;
ignoreComments = settings.IgnoreComments;
checkCharacters = settings.CheckCharacters;
lineNumberOffset = settings.LineNumberOffset;
linePositionOffset = settings.LinePositionOffset;
ps.lineNo = lineNumberOffset + 1;
ps.lineStartPos = -linePositionOffset - 1;
curNode.SetLineInfo(ps.LineNo - 1, ps.LinePos - 1);
parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
nextParsingFunction = ParsingFunction.DocumentContent;
switch (settings.ConformanceLevel)
{
case ConformanceLevel.Auto:
fragmentType = XmlNodeType.None;
break;
case ConformanceLevel.Fragment:
fragmentType = XmlNodeType.Element;
break;
case ConformanceLevel.Document:
fragmentType = XmlNodeType.Document;
break;
default:
Debug.Assert(false);
goto case ConformanceLevel.Document;
}
}
// Parses named character entity reference (& ' < > ").
// Returns -1 if the reference is not a character entity reference.
// Returns -2 if more data is needed in the buffer
// Otherwise
// - replaces the last character of the entity reference (';') with the referenced character (if expand == true)
// - returns position of the end of the character reference, that is of the character next to the original ';'
private int ParseNamedCharRefInline( int startPos, bool expand, BufferBuilder internalSubsetBuilder ) {
Debug.Assert( startPos < ps.charsUsed );
Debug.Assert( ps.chars[startPos] == '&' );
Debug.Assert( ps.chars[startPos + 1] != '#' );
int pos = startPos + 1;
char[] chars = ps.chars;
char ch;
switch ( chars[pos] ) {
// ' or &
case 'a':
pos++;
// &
if ( chars[pos] == 'm' ) {
if ( ps.charsUsed - pos >= 3 ) {
if ( chars[pos+1] == 'p' && chars[pos+2] == ';' ) {
pos += 3;
ch = '&';
goto FoundCharRef;
}
else {
return -1;
}
}
}
// '
else if ( chars[pos] == 'p' ) {
if ( ps.charsUsed - pos >= 4 ) {
if ( chars[pos+1] == 'o' && chars[pos+2] == 's' &&
chars[pos+3] == ';' ) {
pos += 4;
ch = '\'';
goto FoundCharRef;
}
else {
return -1;
}
}
}
else if ( pos < ps.charsUsed ) {
return -1;
}
break;
// &guot;
case 'q':
if ( ps.charsUsed - pos >= 5 ) {
if ( chars[pos+1] == 'u' && chars[pos+2] == 'o' &&
chars[pos+3] == 't' && chars[pos+4] == ';' ) {
pos += 5;
ch = '"';
goto FoundCharRef;
}
else {
return -1;
}
}
break;
// <
case 'l':
if ( ps.charsUsed - pos >= 3 ) {
if ( chars[pos+1] == 't' && chars[pos+2] == ';' ) {
pos += 3;
ch = '<';
goto FoundCharRef;
}
else {
return -1;
}
}
break;
// >
case 'g':
if ( ps.charsUsed - pos >= 3 ) {
if ( chars[pos+1] == 't' && chars[pos+2] == ';' ) {
pos += 3;
ch = '>';
goto FoundCharRef;
}
else {
return -1;
}
}
break;
default:
return -1;
}
// need more data in the buffer
return -2;
FoundCharRef:
Debug.Assert( pos > 0 );
if ( expand ) {
if ( internalSubsetBuilder != null ) {
internalSubsetBuilder.Append( ps.chars, ps.charPos, pos - ps.charPos );
}
ps.chars[pos-1] = ch;
}
return pos;
}
public void WritesByte()
{
var builder = new BufferBuilder();
builder.WriteByte(32);
Assert.That(builder.ToArray(), new EqualConstraint(new[] { 32 }));
}
internal void CopyTo(BufferBuilder sb)
{
CopyTo(0, sb);
}
private void ParseInDocumentDtd( bool saveInternalSubset ) {
LoadParsingBuffer();
scanningFunction = ScanningFunction.QName;
nextScaningFunction = ScanningFunction.Doctype1;
// doctype name
if ( GetToken( false ) != Token.QName ) {
OnUnexpectedError();
}
schemaInfo.DocTypeName = GetNameQualified( true );
// SYSTEM or PUBLIC id
Token token = GetToken( false );
if ( token == Token.SYSTEM || token == Token.PUBLIC ) {
ParseExternalId( token, Token.DOCTYPE, out publicId, out systemId );
token = GetToken( false);
}
switch ( token ) {
case Token.LeftBracket:
if ( saveInternalSubset ) {
SaveParsingBuffer(); // this will cause saving the internal subset right from the point after '['
internalSubsetValueSb = new BufferBuilder();
}
ParseInternalSubset();
break;
case Token.GreaterThan:
break;
default:
OnUnexpectedError();
break;
}
SaveParsingBuffer();
if ( systemId != null && systemId.Length > 0 ) {
ParseExternalSubset();
}
}
internal string InternalReadContentAsString() {
string value = string.Empty;
BufferBuilder sb = null;
do {
switch (this.NodeType) {
case XmlNodeType.Attribute:
return this.Value;
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
case XmlNodeType.CDATA:
// merge text content
if (value.Length == 0) {
value = this.Value;
}
else {
if (sb == null) {
sb = new BufferBuilder();
sb.Append(value);
}
sb.Append(this.Value);
}
break;
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Comment:
case XmlNodeType.EndEntity:
// skip comments, pis and end entity nodes
break;
case XmlNodeType.EntityReference:
if (this.CanResolveEntity) {
this.ResolveEntity();
break;
}
goto default;
case XmlNodeType.EndElement:
default:
goto ReturnContent;
}
} while ((this.AttributeCount != 0) ? this.ReadAttributeValue() : this.Read());
ReturnContent:
return (sb == null) ? value : sb.ToString();
}
internal void CopyTo(int valueOffset, BufferBuilder sb)
{
if (value == null)
{
Debug.Assert(valueStartPos != -1);
Debug.Assert(chars != null);
sb.Append(chars, valueStartPos + valueOffset, valueLength - valueOffset);
}
else
{
if (valueOffset <= 0)
{
sb.Append(value);
}
else
{
sb.Append(value, valueOffset, value.Length - valueOffset);
}
}
}
internal int DtdParserProxy_ParseNumericCharRef( BufferBuilder internalSubsetBuilder ) {
EntityType entType;
return this.ParseNumericCharRef( true, internalSubsetBuilder, out entType );
}
