152ilg = new CodeGenerator(serializerContractTypeBuilder); 232ilg = new CodeGenerator(serializerContractTypeBuilder); 283ilg = new CodeGenerator(baseSerializerTypeBuilder); 325ilg = new CodeGenerator(typedSerializerTypeBuilder); 360ilg = new CodeGenerator(typedSerializerTypeBuilder); 384ilg = new CodeGenerator(typedSerializerTypeBuilder); 436ilg = new CodeGenerator(serializerContractTypeBuilder); 489ilg = new CodeGenerator(serializerContractTypeBuilder); 509ilg = new CodeGenerator(serializerContractTypeBuilder); 540ilg = new CodeGenerator(serializerContractTypeBuilder);

236ilg = new CodeGenerator(this.typeBuilder); 419ilg = new CodeGenerator(this.typeBuilder); 465ilg = new CodeGenerator(this.typeBuilder); 708ilg = new CodeGenerator(this.typeBuilder); 1037ilg = new CodeGenerator(this.typeBuilder); 1109ilg = new CodeGenerator(this.typeBuilder); 1354ilg = new CodeGenerator(this.typeBuilder); 1405ilg = new CodeGenerator(this.typeBuilder);

88ilg = new CodeGenerator(this.typeBuilder); 356ilg = new CodeGenerator(this.typeBuilder); 547ilg = new CodeGenerator(this.typeBuilder); 604ilg = new CodeGenerator(this.typeBuilder); 914ilg = new CodeGenerator(this.typeBuilder);

160ilg.BeginMethod( 166propertyBuilder.SetGetMethod(ilg.MethodBuilder!); 168ilg.Ldarg(0); 169ilg.LoadMember(fieldBuilder); 170ilg.Load(null); 172ilg.If(Cmp.EqualTo); 178LocalBuilder _tmpLoc = ilg.DeclareLocal(typeof(Hashtable), "_tmp"); 179ilg.New(Hashtable_ctor); 180ilg.Stloc(_tmpLoc); 187ilg!.Ldarg(0); 188ilg.LoadMember(fieldBuilder); 189ilg.Load(null); 190ilg.If(Cmp.EqualTo); 192ilg.Ldarg(0); 193ilg.Ldloc(typeof(Hashtable), "_tmp"); 194ilg.StoreMember(fieldBuilder); 196ilg.EndIf(); 198ilg.EndIf(); 200ilg.Ldarg(0); 201ilg.LoadMember(fieldBuilder); 202ilg.GotoMethodEnd(); 204ilg.EndMethod(); 220ilg!.Ldloc(typeof(Hashtable), "_tmp"); 221ilg.Ldstr(GetCSharpString(xmlMappings[i].Key)); 222ilg.Ldstr(GetCSharpString(methods[i])); 223ilg.Call(Hashtable_set_Item); 233ilg.BeginMethod( 253ilg.Ldarg("type"); 254ilg.Ldc(type); 255ilg.If(Cmp.EqualTo); 257ilg.Ldc(true); 258ilg.GotoMethodEnd(); 260ilg.EndIf(); 262ilg.Ldc(false); 263ilg.GotoMethodEnd(); 264ilg.EndMethod(); 284ilg.BeginMethod(typeof(XmlSerializationReader), 289ilg.New(readerCtor); 290ilg.EndMethod(); 296ilg.BeginMethod(typeof(XmlSerializationWriter), 301ilg.New(writerCtor); 302ilg.EndMethod(); 326ilg.BeginMethod( 336ilg.Ldc(true); 337ilg.Stloc(ilg.ReturnLocal); 338ilg.Br(ilg.ReturnLabel); 347ilg.Ldarg(ilg.GetArg("xmlReader")); 348ilg.Ldstr(GetCSharpString(mapping.Accessor.Name)); 349ilg.Ldstr(GetCSharpString(mapping.Accessor.Namespace)); 350ilg.Call(XmlReader_IsStartElement); 351ilg.Stloc(ilg.ReturnLocal); 352ilg.Br(ilg.ReturnLabel); 354ilg.MarkLabel(ilg.ReturnLabel); 355ilg.Ldloc(ilg.ReturnLocal); 356ilg.EndMethod(); 361ilg.BeginMethod( 372ilg.Ldarg("writer"); 373ilg.Castclass(CreatedTypes[writerClass]); 374ilg.Ldarg("objectToSerialize"); 377ilg.ConvertValue(typeof(object), typeof(object[])); 379ilg.Call(writerType_writeMethod); 380ilg.EndMethod(); 385ilg.BeginMethod( 396ilg.Ldarg("reader"); 397ilg.Castclass(CreatedTypes[readerClass]); 398ilg.Call(readerType_readMethod); 399ilg.EndMethod(); 424ilg!.Ldloc(typeof(Hashtable), "_tmp"); 425ilg.Ldstr(GetCSharpString(key)); 426ilg.New(ctor); 427ilg.Call(Hashtable_Add); 437ilg.BeginMethod( 456ilg.Ldarg("type"); 457ilg.Ldc(type); 458ilg.If(Cmp.EqualTo); 464ilg.New(ctor); 465ilg.Stloc(ilg.ReturnLocal); 466ilg.Br(ilg.ReturnLabel); 468ilg.EndIf(); 471ilg.Load(null); 472ilg.Stloc(ilg.ReturnLocal); 473ilg.Br(ilg.ReturnLabel); 474ilg.MarkLabel(ilg.ReturnLabel); 475ilg.Ldloc(ilg.ReturnLocal); 476ilg.EndMethod(); 495ilg.BeginMethod( 501propertyBuilder.SetGetMethod(ilg.MethodBuilder!); 506ilg.New(ctor); 507ilg.EndMethod(); 515ilg.BeginMethod( 521propertyBuilder.SetGetMethod(ilg.MethodBuilder!); 526ilg.New(ctor); 527ilg.EndMethod(); 541ilg.BeginMethod( 548ilg.Ldarg(0); 549ilg.Load(null); 550ilg.StoreMember(readMethodsField); 551ilg.Ldarg(0); 552ilg.Load(null); 553ilg.StoreMember(writeMethodsField); 554ilg.Ldarg(0); 555ilg.Load(null); 556ilg.StoreMember(typedSerializersField); 557ilg.Ldarg(0); 558ilg.Call(baseCtor); 559ilg.EndMethod(); 583ilg!.LoadMember(ilg.GetVariable("o"), memInfo); 587ilg.ConvertValue(memType, type); 592SourceInfo info = new SourceInfo(source, null, null, null, ilg!);

237ilg.BeginMethod(typeof(void), "InitIDs", Type.EmptyTypes, Array.Empty<string>(), 256ilg.Ldarg(0); 257ilg.Ldarg(0); 258ilg.Call(XmlSerializationReader_get_Reader); 259ilg.Call(XmlReader_get_NameTable); 260ilg.Ldstr(GetCSharpString(id)); 261ilg.Call(XmlNameTable_Add); 263ilg.StoreMember(_idNameFields[id]); 265ilg.EndMethod(); 369ilg.Ldarg(0); 370ilg.Call(XmlSerializationReader_get_Reader); 371ilg.Ldarg(0); 372ilg.LoadMember(_idNameFields[name ?? string.Empty]); 373ilg.Ldarg(0); 374ilg.LoadMember(_idNameFields[ns ?? string.Empty]); 375ilg.Call(XmlReader_IsStartElement); 376ilg.If(); 383ilg.Else(); 386ilg.Ldarg(0); 389ilg.Load(null); 392object pVar = ilg.GetVariable("p"); 393ilg.Load(pVar); 394ilg.ConvertValue(CodeGenerator.GetVariableType(pVar), typeof(object)); 402ilg.Ldstr(ReflectionAwareILGen.GetCSharpString(expectedElement)); 410ilg.Call(method); 413ilg.EndIf(); 420ilg.BeginMethod(typeof(void), "InitCallbacks", Type.EmptyTypes, Array.Empty<string>(), 422ilg.EndMethod(); 466ilg.BeginMethod( 473ilg.Load(null); 474ilg.Stloc(ilg.ReturnLocal); 485ilg.Ldarg(0); 486ilg.Call(XmlSerializationReader_get_Reader); 487ilg.Call(XmlReader_MoveToContent); 488ilg.Pop(); 490LocalBuilder localP = ilg.DeclareLocal(typeof(object[]), "p"); 491ilg.NewArray(typeof(object), mappings.Length); 492ilg.Stloc(localP); 582ilg.Ldarg(0); 583ilg.Ldc(true); 584ilg.Call(XmlSerializationReader_set_IsReturnValue); 600ilg.Ldarg(0); 601ilg.Call(XmlSerializationReader_get_Reader); 602ilg.Call(XmlReader_MoveToElement); 603ilg.Pop(); 615ilg.Ldarg(0); 616ilg.Call(XmlSerializationReader_get_Reader); 617ilg.Call(XmlReader_get_IsEmptyElement); 618ilg.If(); 625ilg.Ldarg(0); 626ilg.Call(XmlSerializationReader_get_Reader); 627ilg.Call(XmlReader_Skip); 628ilg.Ldarg(0); 629ilg.Call(XmlSerializationReader_get_Reader); 630ilg.Call(XmlReader_MoveToContent); 631ilg.Pop(); 632ilg.WhileContinue(); 634ilg.EndIf(); 640ilg.Ldarg(0); 641ilg.Call(XmlSerializationReader_get_Reader); 642ilg.Call(XmlReader_ReadStartElement); 646ilg.Ldc(0); 647ilg.Stloc(typeof(int), "state"); 654ilg.Ldarg(0); 655ilg.Call(XmlSerializationReader_get_Reader); 656ilg.Call(XmlReader_MoveToContent); 657ilg.Pop(); 669ilg.Ldarg(0); 670ilg.Call(XmlSerializationReader_ReadEndElement); 675ilg.Ldarg(0); 676ilg.Call(XmlSerializationReader_get_Reader); 677ilg.Call(XmlReader_MoveToContent); 678ilg.Pop(); 682ilg.Ldloc(ilg.GetLocal("p")); 683ilg.EndMethod(); 694LocalBuilder arrayLoc = ilg.GetLocal(arrayName); 695ilg.Ldloc(arrayLoc); 696ilg.Ldc(i); 697ReflectionAwareILGen.ILGenForCreateInstance(ilg, mappings[i].TypeDesc!.Type!, false, false); 698ilg.ConvertValue(mappings[i].TypeDesc!.Type!, typeof(object)); 699ilg.Stelem(arrayLoc.LocalType.GetElementType()!); 709ilg.BeginMethod( 716LocalBuilder oLoc = ilg.DeclareLocal(typeof(object), "o"); 717ilg.Load(null); 718ilg.Stloc(oLoc); 734ilg.Ldarg(0); 735ilg.Call(XmlSerializationReader_get_Reader); 736ilg.Call(XmlReader_MoveToContent); 737ilg.Pop(); 740ilg.Ldloc(oLoc); 742ilg.Stloc(ilg.ReturnLocal); 743ilg.Ldloc(ilg.ReturnLocal); 744ilg.EndMethod(); 770ilg.Ldarg(0); 783ilg.Ldarg(0); 784ilg.Call(XmlSerializationReader_get_Reader); 785ilg.Call(XmlReader_ReadXXXString); 799ilg.Ldarg(0); 800ilg.Call(XmlSerializationReader_get_Reader); 801ilg.Call(XmlReader_get_Value); 805LocalBuilder locVals = ilg.GetLocal("vals"); 806LocalBuilder locI = ilg.GetLocal("i"); 807ilg.LoadArrayElement(locVals, locI); 811ilg.Ldc(false); 817ilg.Call(methodBuilder); 833ilg.Ldarg(0); 834ilg.Call(XmlSerializationReader_get_Reader); 835ilg.Call(XmlReader_ReadXXXString); 849ilg.Ldarg(0); 850ilg.Call(XmlSerializationReader_get_Reader); 851ilg.Call(XmlReader_get_Value); 855LocalBuilder locVals = ilg.GetLocal("vals"); 856LocalBuilder locI = ilg.GetLocal("i"); 857ilg.LoadArrayElement(locVals, locI); 870ilg.Ldarg(0); 871LocalBuilder locVals = ilg.GetLocal("vals"); 872LocalBuilder locI = ilg.GetLocal("i"); 873ilg.LoadArrayElement(locVals, locI); 883ilg.Call(XmlSerializationReader_CollapseWhitespace); 899ilg.Ldarg(0); 900ilg.Ldarg(0); 901ilg.Call(XmlSerializationReader_get_Reader); 902ilg.Call(XmlReader_method); 910ilg.Call(XmlSerializationReader_CollapseWhitespace); 927ilg.Ldarg(0); 956ilg.Ldarg(0); 957ilg.Call(XmlSerializationReader_get_Reader); 958ilg.Call(XmlReader_ReadXXXString); 972ilg.Ldarg(0); 973ilg.Call(XmlSerializationReader_get_Reader); 974ilg.Call(XmlReader_get_Value); 978LocalBuilder locVals = ilg.GetLocal("vals"); 979LocalBuilder locI = ilg.GetLocal("i"); 980ilg.LoadArrayElement(locVals, locI); 985ilg.Ldc(false); 987ilg.Call(ToXXX); 1038ilg.BeginMethod( 1045ilg.Ldarg(0); 1046ilg.LoadMember(fieldBuilder); 1047ilg.Load(null); 1048ilg.If(Cmp.EqualTo); 1054LocalBuilder hLoc = ilg.DeclareLocal(typeof(Hashtable), "h"); 1055ilg.New(Hashtable_ctor); 1056ilg.Stloc(hLoc); 1067ilg.Ldloc(hLoc); 1068ilg.Ldstr(GetCSharpString(constants[i].XmlName)); 1069ilg.Ldc(Enum.ToObject(mapping.TypeDesc!.Type!, constants[i].Value)); 1070ilg.ConvertValue(mapping.TypeDesc.Type!, typeof(long)); 1071ilg.ConvertValue(typeof(long), typeof(object)); 1073ilg.Call(Hashtable_Add); 1076ilg.Ldarg(0); 1077ilg.Ldloc(hLoc); 1078ilg.StoreMember(fieldBuilder); 1080ilg.EndIf(); 1082ilg.Ldarg(0); 1083ilg.LoadMember(fieldBuilder); 1085get_TableName = ilg.EndMethod(); 1110ilg.BeginMethod( 1126ilg.Ldarg("s"); 1127ilg.Ldarg(0); 1129ilg.Call(get_TableName); 1130ilg.Ldstr(GetCSharpString(fullTypeName)); 1131ilg.Call(XmlSerializationReader_ToEnum); 1135ilg.ConvertValue(typeof(long), underlyingType); 1137ilg.Stloc(ilg.ReturnLocal); 1138ilg.Br(ilg.ReturnLabel); 1145Label defaultLabel = ilg.DefineLabel(); 1146Label endSwitchLabel = ilg.DefineLabel(); 1148LocalBuilder localTmp = ilg.GetTempLocal(typeof(string)); 1149ilg.Ldarg("s"); 1150ilg.Stloc(localTmp); 1151ilg.Ldloc(localTmp); 1152ilg.Brfalse(defaultLabel); 1161Label caseLabel = ilg.DefineLabel(); 1162ilg.Ldloc(localTmp); 1163ilg.Ldstr(GetCSharpString(c.XmlName)); 1169ilg.Call(String_op_Equality); 1170ilg.Brtrue(caseLabel); 1176ilg.Br(defaultLabel); 1180ilg.MarkLabel(caseLabels[i]); 1181ilg.Ldc(retValues[i]); 1182ilg.Stloc(ilg.ReturnLocal); 1183ilg.Br(ilg.ReturnLabel); 1191ilg.MarkLabel(defaultLabel); 1192ilg.Ldarg(0); 1193ilg.Ldarg("s"); 1195ilg.Ldc(mapping.TypeDesc.Type!); 1196ilg.Call(XmlSerializationReader_CreateUnknownConstantException); 1197ilg.Throw(); 1199ilg.MarkLabel(endSwitchLabel); 1202ilg.MarkLabel(ilg.ReturnLabel); 1203ilg.Ldloc(ilg.ReturnLocal); 1204ilg.EndMethod(); 1211ilg.InitElseIf(); 1213ilg.AndIf(); 1222ilg.Ldarg(0); 1225ilg.Ldarg("isNullable"); 1228ilg.Ldc(false); 1237ilg.Call(methodBuilder); 1238ilg.ConvertValue(methodBuilder.ReturnType, ilg.ReturnLocal.LocalType); 1239ilg.Stloc(ilg.ReturnLocal); 1240ilg.Br(ilg.ReturnLabel); 1254ilg.InitElseIf(); 1256ilg.AndIf(); 1267ilg.Ldarg(0); 1268ilg.Call(XmlSerializationReader_get_Reader); 1269ilg.Call(XmlReader_ReadStartElement); 1275LocalBuilder eLoc = ilg.DeclareOrGetLocal(typeof(object), "e"); 1292ilg.Ldarg(0); 1293ilg.Ldarg(0); 1294ilg.Ldarg(0); 1295ilg.Call(XmlSerializationReader_get_Reader); 1296ilg.Call(XmlReader_ReadString); 1297ilg.Call(XmlSerializationReader_CollapseWhitespace); 1298ilg.Call(methodBuilder); 1299ilg.ConvertValue(methodBuilder.ReturnType, eLoc.LocalType); 1300ilg.Stloc(eLoc); 1306ilg.Ldarg(0); 1307ilg.Call(XmlSerializationReader_ReadEndElement); 1308ilg.Ldloc(eLoc); 1309ilg.Stloc(ilg.ReturnLocal); 1310ilg.Br(ilg.ReturnLabel); 1317ilg.InitElseIf(); 1319ilg.AndIf(); 1320ilg.EnterScope(); 1329LocalBuilder aLoc = ilg.DeclareLocal(arrayMapping.TypeDesc.Type!, aVar); 1332ReflectionAwareILGen.ILGenForCreateInstance(ilg, td.Type!, false, false); 1335ilg.Load(null); 1336ilg.Stloc(aLoc); 1339ilg.Ldloc(aLoc); 1340ilg.Stloc(ilg.ReturnLocal); 1341ilg.Br(ilg.ReturnLabel); 1342ilg.ExitScope(); 1355ilg.BeginMethod( 1362LocalBuilder oLoc = ilg.DeclareLocal(nullableMapping.TypeDesc.Type!, "o"); 1364ilg.LoadAddress(oLoc); 1365ilg.InitObj(nullableMapping.TypeDesc.Type!); 1370ilg.Ldarg(0); 1371ilg.Call(XmlSerializationReader_ReadNull); 1372ilg.If(); 1374ilg.Ldloc(oLoc); 1375ilg.Stloc(ilg.ReturnLocal); 1376ilg.Br(ilg.ReturnLabel); 1378ilg.EndIf(); 1386ilg.Ldloc(oLoc); 1387ilg.Stloc(ilg.ReturnLocal); 1388ilg.Br(ilg.ReturnLabel); 1390ilg.MarkLabel(ilg.ReturnLabel); 1391ilg.Ldloc(ilg.ReturnLocal); 1392ilg.EndMethod(); 1415ilg.BeginMethod( 1422LocalBuilder locXsiType = ilg.DeclareLocal(typeof(XmlQualifiedName), "xsiType"); 1423LocalBuilder locIsNull = ilg.DeclareLocal(typeof(bool), "isNull"); 1434Label labelTrue = ilg.DefineLabel(); 1435Label labelEnd = ilg.DefineLabel(); 1436ilg.Ldarg("checkType"); 1437ilg.Brtrue(labelTrue); 1438ilg.Load(null); 1439ilg.Br_S(labelEnd); 1440ilg.MarkLabel(labelTrue); 1441ilg.Ldarg(0); 1442ilg.Call(XmlSerializationReader_GetXsiType); 1443ilg.MarkLabel(labelEnd); 1444ilg.Stloc(locXsiType); 1445ilg.Ldc(false); 1446ilg.Stloc(locIsNull); 1449ilg.Ldarg("isNullable"); 1450ilg.If(); 1452ilg.Ldarg(0); 1453ilg.Call(XmlSerializationReader_ReadNull); 1454ilg.Stloc(locIsNull); 1456ilg.EndIf(); 1459ilg.Ldarg("checkType"); 1460ilg.If(); // if (checkType) 1463ilg.Ldloc(locIsNull); 1464ilg.If(); 1465ilg.Ldloc(locXsiType); 1466ilg.Load(null); 1467ilg.If(Cmp.NotEqualTo); 1473ilg.Ldarg(0); 1474ilg.Ldloc(locXsiType); 1475ilg.Call(XmlSerializationReader_ReadTypedNull); 1476ilg.Stloc(ilg.ReturnLocal); 1477ilg.Br(ilg.ReturnLabel); 1478ilg.Else(); 1485ilg.Load(null); 1486ilg.Stloc(ilg.ReturnLocal); 1487ilg.Br(ilg.ReturnLabel); 1489ilg.EndIf(); // if (xsiType != null) 1491ilg.EndIf(); // if (isNull) 1493ilg.Ldloc(typeof(XmlQualifiedName), "xsiType"); 1494ilg.Load(null); 1495ilg.Ceq(); 1498labelTrue = ilg.DefineLabel(); 1499labelEnd = ilg.DefineLabel(); 1501ilg.Brtrue(labelTrue); 1504ilg.Br_S(labelEnd); 1505ilg.MarkLabel(labelTrue); 1506ilg.Ldc(true); 1507ilg.MarkLabel(labelEnd); 1509ilg.If(); // if (xsiType == null 1521ilg.Ldarg(0); 1522ilg.Ldstr(Soap.UrType); 1523ilg.Ldstr(XmlSchema.Namespace); 1524ilg.New(XmlQualifiedName_ctor); 1525ilg.Call(XmlSerializationReader_ReadTypedPrimitive); 1526ilg.Stloc(ilg.ReturnLocal); 1527ilg.Br(ilg.ReturnLabel); 1531ilg.Else(); // if (xsiType == null 1539ilg.Ldarg(0); 1540ilg.Ldloc(locXsiType); 1541ilg.Call(XmlSerializationReader_ReadTypedPrimitive); 1542ilg.Stloc(ilg.ReturnLocal); 1543ilg.Br(ilg.ReturnLabel); 1552ilg.Ldarg(0); 1553ilg.Ldloc(locXsiType); 1554ilg.Call(XmlSerializationReader_CreateUnknownTypeException); 1555ilg.Throw(); 1557ilg.EndIf(); // if (xsiType == null 1558ilg.EndIf(); // checkType 1562ilg.Ldloc(typeof(bool), "isNull"); 1563ilg.If(); 1565ilg.Load(null); 1566ilg.Stloc(ilg.ReturnLocal); 1567ilg.Br(ilg.ReturnLabel); 1569ilg.EndIf(); 1579ilg.Ldarg(0); 1580ilg.Ldstr(GetCSharpString(structMapping.TypeName)); 1581ilg.Ldstr(GetCSharpString(structMapping.Namespace)); 1582ilg.Call(XmlSerializationReader_CreateAbstractTypeException); 1583ilg.Throw(); 1594ilg.Ldarg(0); 1595ilg.Ldc(false); 1596ilg.Call(XmlSerializationReader_set_DecodeName); 1599LocalBuilder oLoc = ilg.GetLocal("o"); 1698ilg.Ldarg(0); 1699ilg.Call(XmlSerializationReader_get_Reader); 1700ilg.Call(XmlReader_MoveToElement); 1701ilg.Pop(); 1708ilg.Ldarg(0); 1709ilg.Call(XmlSerializationReader_get_Reader); 1710ilg.Call(XmlReader_get_IsEmptyElement); 1711ilg.If(); 1717ilg.Ldarg(0); 1718ilg.Call(XmlSerializationReader_get_Reader); 1719ilg.Call(XmlReader_Skip); 1721ilg.Ldloc(oLoc); 1722ilg.Stloc(ilg.ReturnLocal); 1723ilg.Br(ilg.ReturnLabel); 1724ilg.EndIf(); 1731ilg.Ldarg(0); 1732ilg.Call(XmlSerializationReader_get_Reader); 1733ilg.Call(XmlReader_ReadStartElement); 1736ilg.Ldc(0); 1737ilg.Stloc(typeof(int), "state"); 1747ilg.Ldarg(0); 1748ilg.Call(XmlSerializationReader_get_Reader); 1749ilg.Call(XmlReader_MoveToContent); 1750ilg.Pop(); 1760ilg.Ldarg(0); 1761ilg.Call(XmlSerializationReader_ReadEndElement); 1762ilg.Ldloc(structMapping.TypeDesc.Type!, "o"); 1763ilg.Stloc(ilg.ReturnLocal); 1765ilg.MarkLabel(ilg.ReturnLabel); 1766ilg.Ldloc(ilg.ReturnLocal); 1767ilg.EndMethod(); 1786Label labelEnd = ilg.DefineLabel(); 1787Label labelFalse = ilg.DefineLabel(); 1788LocalBuilder sLoc = ilg.GetLocal(source); 1789ilg.Ldloc(sLoc); 1790ilg.Call(XmlQualifiedName_get_Name); 1791ilg.Ldarg(0); 1792ilg.LoadMember(_idNameFields[name ?? string.Empty]); 1793ilg.Bne(labelFalse); 1794ilg.Ldloc(sLoc); 1795ilg.Call(XmlQualifiedName_get_Namespace); 1796ilg.Ldarg(0); 1797ilg.LoadMember(_idNameFields[ns ?? string.Empty]); 1798ilg.Ceq(); 1799ilg.Br_S(labelEnd); 1800ilg.MarkLabel(labelFalse); 1801ilg.Ldc(false); 1802ilg.MarkLabel(labelEnd); 1835Label labelFalse = ilg.DefineLabel(); 1836Label labelEnd = ilg.DefineLabel(); 1840ilg.Ldarg(0); 1841ilg.Call(XmlSerializationReader_get_Reader); 1842ilg.Call(XmlReader_get_LocalName); 1843ilg.Ldarg(0); 1844ilg.LoadMember(_idNameFields[name ?? string.Empty]); 1845ilg.Bne(labelFalse); 1848ilg.Ldarg(0); 1849ilg.Call(XmlSerializationReader_get_Reader); 1850ilg.Call(XmlReader_get_NamespaceURI); 1851ilg.Ldarg(0); 1852ilg.LoadMember(_idNameFields[ns ?? string.Empty]); 1853ilg.Ceq(); 1857ilg.Br_S(labelEnd); 1858ilg.MarkLabel(labelFalse); 1859ilg.Ldc(false); 1860ilg.MarkLabel(labelEnd); 1863ilg.AndIf(); 1894ilg.WhileBegin(); 1915ilg.InitElseIf(); 1917ilg.InitIf(); 1922ilg.Ldc(false); 1923ilg.AndIf(Cmp.EqualTo); 1937ilg.InitElseIf(); 1939ilg.InitIf(); 1963ilg.Ldarg(0); 1964ilg.Ldarg(0); 1965ilg.Call(XmlSerializationReader_get_Reader); 1966ilg.Call(XmlReader_get_Name); 1967ilg.Call(XmlSerializationReader_IsXmlnsAttribute); 1968ilg.Ldc(true); 1969ilg.AndIf(Cmp.EqualTo); 1972ilg.Load(null); 1973ilg.If(Cmp.EqualTo); 1979ilg.New(ctor); 1981ilg.EndIf(); // if (xmlnsMember.Source == null 1983Label labelEqual5 = ilg.DefineLabel(); 1984Label labelEndLength = ilg.DefineLabel(); 1996ilg.Ldarg(0); 1997ilg.Call(XmlSerializationReader_get_Reader); 1998ilg.Call(XmlReader_get_Name); 1999ilg.Call(String_get_Length); 2000ilg.Ldc(5); 2001ilg.Beq(labelEqual5); 2002ilg.Ldarg(0); 2003ilg.Call(XmlSerializationReader_get_Reader); 2004ilg.Call(XmlReader_get_LocalName); 2005ilg.Br(labelEndLength); 2006ilg.MarkLabel(labelEqual5); 2007ilg.Ldstr(string.Empty); 2008ilg.MarkLabel(labelEndLength); 2009ilg.Ldarg(0); 2010ilg.Call(XmlSerializationReader_get_Reader); 2011ilg.Call(XmlReader_get_Value); 2012ilg.Call(Add); 2014ilg.Else(); 2028ilg.Ldarg(0); 2029ilg.Ldarg(0); 2030ilg.Call(XmlSerializationReader_get_Reader); 2031ilg.Call(XmlReader_get_Name); 2032ilg.Call(XmlSerializationReader_IsXmlnsAttribute); 2033ilg.Ldc(false); 2034ilg.AndIf(Cmp.EqualTo); 2038LocalBuilder localAttr = ilg.DeclareOrGetLocal(typeof(XmlAttribute), "attr"); 2049ilg.Ldarg(0); 2050ilg.Call(XmlSerializationReader_get_Document); 2051ilg.Ldarg(0); 2052ilg.Call(XmlSerializationReader_get_Reader); 2053ilg.Call(XmlDocument_ReadNode); 2054ilg.ConvertValue(XmlDocument_ReadNode.ReturnType, localAttr.LocalType); 2055ilg.Stloc(localAttr); 2061ilg.Ldarg(0); 2062ilg.Ldloc(localAttr); 2063ilg.Call(XmlSerializationReader_ParseWsdlArrayType); 2069ilg.Ldarg(0); 2071ilg.Ldloc(firstParam); 2072ilg.ConvertValue(firstParam.LocalType, typeof(object)); 2085ilg.Ldstr(qnames); 2093ilg.Call(elseCallMethod); 2095ilg.EndIf(); 2097ilg.WhileBeginCondition(); 2099ilg.Ldarg(0); 2100ilg.Call(XmlSerializationReader_get_Reader); 2101ilg.Call(XmlReader_MoveToNextAttribute); 2103ilg.WhileEndCondition(); 2104ilg.WhileEnd(); 2116ilg.Ldloc("attr"); 2121LocalBuilder attrLoc = ilg.GetLocal("attr"); 2122ilg.Ldloc(attrLoc); 2126ilg.Load(null); 2127ilg.Cne(); 2130ilg.IsInst(typeof(XmlAttribute)); 2131ilg.If(); 2133ilg.Ldloc(attrLoc); 2134ilg.ConvertValue(attrLoc.LocalType, typeof(XmlAttribute)); 2136ilg.EndIf(); 2149LocalBuilder locVals = ilg.DeclareOrGetLocal(typeof(string[]), "vals"); 2165ilg.Ldarg(0); 2166ilg.Call(XmlSerializationReader_get_Reader); 2167ilg.Call(XmlReader_get_Value); 2168ilg.LoadMember(EnsureXmlListSeparatorsField()); 2169ilg.Call(String_Split); 2170ilg.Stloc(locVals); 2171LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(int), "i"); 2172ilg.For(localI, 0, locVals); 2179ilg.EndFor(); 2215ilg.Ldc(0); 2216ilg.Stloc(typeof(int), c); 2223ilg.Ldc(0); 2224ilg.Stloc(typeof(int), $"c{member.ChoiceArrayName}"); 2233ilg.Ldloc(ilg.GetLocal(a)); 2242ilg.Load(null); 2243ilg.If(Cmp.EqualTo); 2251ilg.Ldarg(0); 2252ilg.Ldstr(GetCSharpString(member.Mapping.TypeDesc.CSharpName)); 2253ilg.Call(XmlSerializationReader_CreateReadOnlyCollectionException); 2254ilg.Throw(); 2259ReflectionAwareILGen.ILGenForCreateInstance(ilg, member.Mapping.TypeDesc.Type!, typeDesc.CannotNew, true); 2262ilg.EndIf(); // if ((object)(member.Source) == null 2264WriteLocalDecl(a, new SourceInfo(member.Source, member.Source, member.Mapping.MemberInfo, member.Mapping.TypeDesc.Type, ilg)); 2308ilg.Load(null); 2309ilg.Stloc(typeof(string), "tmp"); 2323ilg.Ldarg(0); 2324ilg.Call(XmlSerializationReader_get_Reader); 2325ilg.Call(XmlReader_get_NodeType); 2326ilg.Ldc(XmlNodeType_Element); 2327ilg.If(Cmp.EqualTo); 2334ilg.Else(); 2336ilg.EndIf(); 2341ilg.InitElseIf(); 2342Label labelTrue = ilg.DefineLabel(); 2343Label labelEnd = ilg.DefineLabel(); 2354ilg.Ldarg(0); 2355ilg.Call(XmlSerializationReader_get_Reader); 2356ilg.Call(XmlReader_get_NodeType); 2357ilg.Ldc(XmlNodeType.Text); 2358ilg.Ceq(); 2359ilg.Brtrue(labelTrue); 2360ilg.Ldarg(0); 2361ilg.Call(XmlSerializationReader_get_Reader); 2362ilg.Call(XmlReader_get_NodeType); 2363ilg.Ldc(XmlNodeType.CDATA); 2364ilg.Ceq(); 2365ilg.Brtrue(labelTrue); 2366ilg.Ldarg(0); 2367ilg.Call(XmlSerializationReader_get_Reader); 2368ilg.Call(XmlReader_get_NodeType); 2369ilg.Ldc(XmlNodeType.Whitespace); 2370ilg.Ceq(); 2371ilg.Brtrue(labelTrue); 2372ilg.Ldarg(0); 2373ilg.Call(XmlSerializationReader_get_Reader); 2374ilg.Call(XmlReader_get_NodeType); 2375ilg.Ldc(XmlNodeType.SignificantWhitespace); 2376ilg.Ceq(); 2377ilg.Br(labelEnd); 2378ilg.MarkLabel(labelTrue); 2379ilg.Ldc(true); 2380ilg.MarkLabel(labelEnd); 2381ilg.AndIf(); 2420ilg.Ldarg(0); 2421ilg.Call(XmlSerializationReader_get_Document); 2422ilg.Ldarg(0); 2423ilg.Call(XmlSerializationReader_get_Reader); 2424ilg.Call(XmlReader_ReadString); 2425ilg.Call(XmlDocument_CreateTextNode); 2441LocalBuilder locVals = ilg.DeclareOrGetLocal(typeof(string[]), "vals"); 2457ilg.Ldarg(0); 2458ilg.Call(XmlSerializationReader_get_Reader); 2459ilg.Call(XmlReader_ReadContentAsString); 2460ilg.LoadMember(EnsureXmlListSeparatorsField()); 2461ilg.Ldc((int)StringSplitOptions.RemoveEmptyEntries); 2462ilg.Call(String_Split); 2463ilg.Stloc(locVals); 2464LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(int), "i"); 2465ilg.For(localI, 0, locVals); 2469ilg.EndFor(); 2478ilg.Ldarg(0); // for calling CollapseWhitespace 2493ilg.Ldarg(0); 2494ilg.Call(XmlSerializationReader_get_Reader); 2495ilg.Call(XmlReader_ReadString); 2503ilg.Call(XmlSerializationReader_CollapseWhitespace); 2510LocalBuilder tmpLoc = ilg.GetLocal("tmp"); 2516ilg.Ldarg(0); 2517ilg.Ldloc(tmpLoc); 2518ilg.Ldc(text.Mapping.TypeDesc!.CollapseWhitespace); 2519ilg.Call(XmlSerializationReader_ReadString); 2520ilg.Stloc(tmpLoc); 2523ilg.Ldloc(tmpLoc); 2594ilg.InitElseIf(); 2599ilg.InitElseIf(); 2601ilg.InitIf(); 2602ilg.Ldloc("state"); 2603ilg.Ldc(cases); 2604ilg.AndIf(Cmp.EqualTo); 2605ilg.InitIf(); 2609ilg.InitIf(); 2616ilg.Ldc(false); 2617ilg.AndIf(Cmp.EqualTo); 2619Label labelTrue = ilg.DefineLabel(); 2620Label labelEnd = ilg.DefineLabel(); 2628ilg.Ldarg(0); 2629ilg.Call(XmlSerializationReader_get_IsReturnValue); 2630ilg.Brtrue(labelTrue); 2634ilg.Ldc(true); 2642ilg.Br_S(labelEnd); 2643ilg.MarkLabel(labelTrue); 2644ilg.Ldc(true); 2645ilg.MarkLabel(labelEnd); 2647ilg.AndIf(); 2657ilg.Ldarg(0); 2658ilg.Ldc(false); 2659ilg.Call(XmlSerializationReader_set_IsReturnValue); 2670ilg.Else(); 2674ilg.EndIf(); 2677ilg.Ldc(cases); 2678ilg.Stloc(ilg.GetLocal("state")); 2681ilg.EndIf(); 2687ilg.Else(); 2692ilg.EndIf(); 2757ilg.Ldarg(0); 2758ilg.Ldloc(ilg.GetLocal(a)); 2759ilg.Ldloc(ilg.GetLocal(c)); 2760ilg.Ldc(typeDesc.ArrayElementTypeDesc!.Type!); 2761ilg.Ldc(member.IsNullable); 2762ilg.Call(XmlSerializationReader_ShrinkArray); 2763ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, typeDesc.Type!); 2772ilg.Ldarg(0); 2773ilg.Ldloc(ilg.GetLocal(a)); 2774ilg.Ldloc(ilg.GetLocal(c)); 2775ilg.Ldc(member.Mapping.ChoiceIdentifier.Mapping!.TypeDesc!.Type!); 2776ilg.Ldc(member.IsNullable); 2777ilg.Call(XmlSerializationReader_ShrinkArray); 2778ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, member.Mapping.ChoiceIdentifier.Mapping.TypeDesc.Type!.MakeArrayType()); 2784LocalBuilder arrayLoc = ilg.GetLocal(member.ArrayName); 2786ilg.Ldloc(arrayLoc); 2807if (ilg.TryGetVariable(source, out variable)) 2813ilg.LoadAddress(variable); 2820ilg.LdlocAddress(ilg.GetLocal("o")); 2831LocalBuilder localA = ilg.GetLocal(match.Groups["locA1"].Value); 2832LocalBuilder localI = ilg.GetLocal(match.Groups["locI1"].Value); 2839ilg.Ldarg(0); 2840ilg.Ldloc(localA); 2841ilg.Ldloc(localI); 2842ilg.Ldc(arrayElementType); 2843ilg.Call(XmlSerializationReader_EnsureArrayIndex); 2844ilg.Castclass(localA.LocalType); 2845ilg.Stloc(localA); 2848ilg.Ldloc(localA); 2849ilg.Ldloc(localI); 2850ilg.Dup(); 2851ilg.Ldc(1); 2852ilg.Add(); 2853ilg.Stloc(localI); 2856ilg.Ldelema(arrayElementType); 2864LocalBuilder localA = ilg.GetLocal(source.Substring(0, index)); 2865ilg.LdlocAddress(localA); 2873System.Diagnostics.Debug.Assert(CodeGenerator.GetVariableType(ilg.GetVariable(match.Groups["a"].Value)).IsArray); 2874ilg.Load(ilg.GetVariable(match.Groups["a"].Value)); 2875ilg.Load(ilg.GetVariable(match.Groups["ia"].Value)); 2888if (ilg.TryGetVariable(source, out variable)) 2893ilg.Call(varType.GetConstructor(varType.GetGenericArguments())!); 2898ilg.ConvertValue(stackType, elementType); 2899ilg.ConvertValue(elementType, varType); 2900ilg.Stloc((LocalBuilder)variable); 2909ilg.ConvertValue(stackType, memInfo is FieldInfo ? ((FieldInfo)memInfo).FieldType : ((PropertyInfo)memInfo).PropertyType); 2910ilg.StoreMember(memInfo); 2917object oVar = ilg.GetVariable(match.Groups["locA1"].Value); 2919ilg.ConvertValue(elementType, arrayElementType); 2922ilg.Stobj(arrayElementType); 2926ilg.Stelem(arrayElementType); 2934LocalBuilder localA = ilg.GetLocal(source.Substring(0, index)); 2943ilg.ConvertValue(stackType, addParameterType); 2944ilg.Call(Add); 2946ilg.Pop(); 2953Type varType = CodeGenerator.GetVariableType(ilg.GetVariable(match.Groups["a"].Value)); 2956ilg.ConvertValue(stackType, varElementType); 2957ilg.Stelem(varElementType); 3010ilg.Ldarg(0); 3011ilg.Call(XmlSerializationReader_GetNullAttr); 3012ilg.Ldc(false); 3013ilg.If(Cmp.EqualTo); 3020ilg.WhileBegin(); 3021ilg.Ldarg(0); 3022ilg.Ldarg(0); 3023ilg.Call(XmlSerializationReader_get_Reader); 3024ilg.Call(XmlReader_get_Name); 3025ilg.Call(XmlSerializationReader_IsXmlnsAttribute); 3026ilg.Ldc(false); 3027ilg.If(Cmp.EqualTo); 3029ilg.Ldarg(0); 3030ilg.Load(null); 3031ilg.Call(XmlSerializationReader_UnknownNode); 3033ilg.EndIf(); 3034ilg.WhileBeginCondition(); 3036ilg.Ldarg(0); 3037ilg.Call(XmlSerializationReader_get_Reader); 3038ilg.Call(XmlReader_MoveToNextAttribute); 3040ilg.WhileEndCondition(); 3041ilg.WhileEnd(); 3044ilg.Ldarg(0); 3045ilg.Call(XmlSerializationReader_get_Reader); 3046ilg.Call(XmlReader_MoveToElement); 3047ilg.Pop(); 3049ilg.EndIf(); 3064ilg.Ldarg(0); 3065ilg.Call(XmlSerializationReader_ReadNull); 3066ilg.IfNot(); // if (!ReadNull()) { // EnterScope 3067ilg.EnterScope(); 3083Label labelTrue = ilg.DefineLabel(); 3084Label labelEnd = ilg.DefineLabel(); 3088ilg.Load(ilg.GetVariable(member.ArrayName)); 3089ilg.Load(null); 3090ilg.Beq(labelTrue); 3105ilg.Ldarg(0); 3106ilg.Call(XmlSerializationReader_get_Reader); 3107ilg.Call(XmlReader_get_IsEmptyElement); 3110ilg.Br_S(labelEnd); 3111ilg.MarkLabel(labelTrue); 3112ilg.Ldc(true); 3113ilg.MarkLabel(labelEnd); 3115ilg.If(); 3121ilg.Ldarg(0); 3122ilg.Call(XmlSerializationReader_get_Reader); 3123ilg.Call(XmlReader_Skip); 3124ilg.Else(); 3131ilg.Ldarg(0); 3132ilg.Call(XmlSerializationReader_get_Reader); 3133ilg.Call(XmlReader_ReadStartElement); 3143ilg.Ldarg(0); 3144ilg.Call(XmlSerializationReader_get_Reader); 3145ilg.Call(XmlReader_MoveToContent); 3146ilg.Pop(); 3154ilg.Ldarg(0); 3155ilg.Call(XmlSerializationReader_ReadEndElement); 3156ilg.EndIf(); 3162ilg.ExitScope(); // if (!ReadNull()) { ExitScope 3163ilg.Else(); // } else { EnterScope 3164ilg.EnterScope(); 3169ilg.ExitScope(); // if (!ReadNull())/else ExitScope 3170ilg.EndIf(); 3192ilg.Ldarg(0); 3193ilg.Ldc(true); 3201ilg.Call(methodBuilder); 3218ilg.Ldarg(0); 3219ilg.Call(XmlSerializationReader_ReadNull); 3220ilg.If(); 3228ilg.Load(null); 3231ilg.Else(); 3246ilg.Ldarg(0); 3247ilg.Call(XmlSerializationReader_get_Reader); 3248ilg.Call(XmlReader_get_IsEmptyElement); 3249ilg.If(); 3255ilg.Ldarg(0); 3256ilg.Call(XmlSerializationReader_get_Reader); 3257ilg.Call(XmlReader_Skip); 3258ilg.Else(); 3278ilg.Ldarg(0); 3279ilg.Call(XmlSerializationReader_get_Reader); 3280ilg.Call(XmlReader_get_IsEmptyElement); 3281ilg.If(); 3288ilg.Ldarg(0); 3289ilg.Call(XmlSerializationReader_get_Reader); 3290ilg.Call(XmlReader_Skip); 3291LocalBuilder tmpLoc = ilg.GetTempLocal(element.Mapping.TypeDesc!.Type); 3292ilg.Ldloca(tmpLoc); 3293ilg.InitObj(element.Mapping.TypeDesc!.Type); 3294ilg.Ldloc(tmpLoc); 3296ilg.Else(); 3300ilg.EndIf(); 3312ilg.Ldarg(0); 3313ilg.Call(XmlSerializationReader_ReadElementQualifiedName); 3335ilg.EndIf(); 3358ilg.Ldloc(arrayName!); 3359ilg.Load(null); 3360ilg.If(Cmp.EqualTo); 3361ilg.Ldarg(0); 3362ilg.Call(XmlSerializationReader_get_Reader); 3363ilg.Call(XmlReader_Skip); 3364ilg.Else(); 3368ilg.Ldarg(0); 3371ilg.Load(element.IsNullable); 3374ilg.Ldc(true); 3382ilg.Call(methodBuilder); 3386ilg.EndIf(); 3400ilg.Ldarg(0); 3401ilg.Ldc(element.Any ? false : true); 3402ilg.Call(XmlSerializationReader_ReadXmlXXX); 3405ilg.Castclass(special.TypeDesc.Type!); 3418Label labelTrue = ilg.DefineLabel(); 3419Label labelEnd = ilg.DefineLabel(); 3420LocalBuilder tserLoc = ilg.DeclareOrGetLocal(typeof(XmlQualifiedName), "tser"); 3421ilg.Ldarg(0); 3422ilg.Call(XmlSerializationReader_GetXsiType); 3423ilg.Stloc(tserLoc); 3424ilg.Ldloc(tserLoc); 3425ilg.Load(null); 3426ilg.Ceq(); 3427ilg.Brtrue(labelTrue); 3430ilg.Br_S(labelEnd); 3431ilg.MarkLabel(labelTrue); 3432ilg.Ldc(true); 3433ilg.MarkLabel(labelEnd); 3434ilg.If(); 3443ilg.Ldarg(0); 3444ReflectionAwareILGen.ILGenForCreateInstance(ilg, sm.TypeDesc!.Type!, sm.TypeDesc.CannotNew, false); 3446ilg.ConvertValue(typeof(object), typeof(IXmlSerializable)); 3448ilg.ConvertValue(sm.TypeDesc.Type!, typeof(IXmlSerializable)); 3450ilg.Ldc(true); 3451ilg.Call(XmlSerializationReader_ReadSerializable); 3454ilg.ConvertValue(typeof(IXmlSerializable), sm.TypeDesc.Type!); 3479ReflectionAwareILGen.ILGenForEnumMember(ilg, choice.Mapping!.TypeDesc!.Type!, choice.MemberIds[elementIndex]); 3490Label labelTrue = ilg.DefineLabel(); 3491Label labelEnd = ilg.DefineLabel(); 3492LocalBuilder tserLoc = ilg.GetLocal("tser"); 3493ilg.InitElseIf(); 3494ilg.Ldloc(tserLoc); 3495ilg.Load(null); 3496ilg.Ceq(); 3497ilg.Brtrue(labelTrue); 3500ilg.Br_S(labelEnd); 3501ilg.MarkLabel(labelTrue); 3502ilg.Ldc(true); 3503ilg.MarkLabel(labelEnd); 3504ilg.AndIf(); 3516ilg.Ldarg(0); 3517ReflectionAwareILGen.ILGenForCreateInstance(ilg, derived.TypeDesc!.Type!, derived.TypeDesc.CannotNew, false); 3519ilg.ConvertValue(typeof(object), typeof(IXmlSerializable)); 3521ilg.Ldc(true); 3522ilg.Call(XmlSerializationReader_ReadSerializable); 3525ilg.ConvertValue(typeof(IXmlSerializable), head.TypeDesc.Type!); 3535ilg.Ldarg(0); 3536ilg.Ldstr(GetCSharpString(derived.XsiType.Name)); 3537ilg.Ldstr(GetCSharpString(derived.XsiType.Namespace)); 3538ilg.Ldstr(GetCSharpString(head.XsiType!.Name)); 3539ilg.Ldstr(GetCSharpString(head.XsiType.Namespace)); 3540ilg.Ldstr(GetCSharpString(derived.Type.FullName)); 3541ilg.Ldstr(GetCSharpString(head.Type.FullName)); 3542ilg.Call(XmlSerializationReader_CreateBadDerivationException); 3543ilg.Throw(); 3553ilg.Ldarg(0); 3554ilg.Ldstr(GetCSharpString(derived.XsiType.Name)); 3555ilg.Ldstr(GetCSharpString(derived.XsiType.Namespace)); 3556ilg.Ldstr(GetCSharpString(head.Type!.FullName)); 3557ilg.Call(XmlSerializationReader_CreateMissingIXmlSerializableType); 3558ilg.Throw(); 3578ilg.Ldarg(0); 3579ilg.Call(XmlSerializationReader_get_Reader); 3580ilg.Call(XmlReader_MoveToContent); 3581ilg.Pop(); 3582ilg.WhileBegin(); 3587ilg.WhileBeginCondition(); 3603Label labelFalse = ilg.DefineLabel(); 3604Label labelEnd = ilg.DefineLabel(); 3605ilg.Ldarg(0); 3606ilg.Call(XmlSerializationReader_get_Reader); 3607ilg.Call(XmlReader_get_NodeType); 3608ilg.Ldc(XmlNodeType_EndElement); 3609ilg.Beq(labelFalse); 3610ilg.Ldarg(0); 3611ilg.Call(XmlSerializationReader_get_Reader); 3612ilg.Call(XmlReader_get_NodeType); 3613ilg.Ldc(XmlNodeType_None); 3614ilg.Cne(); 3615ilg.Br_S(labelEnd); 3616ilg.MarkLabel(labelFalse); 3617ilg.Ldc(false); 3618ilg.MarkLabel(labelEnd); 3620ilg.WhileEndCondition(); 3621ilg.WhileEnd(); 3632LocalBuilder paramsRead = ilg.DeclareLocal(typeof(Span<bool>), "paramsRead"); 3635ilg.StackallocSpan(typeof(bool), length); 3639ilg.NewArray(typeof(bool), length); 3640ilg.New(typeof(Span<bool>).GetConstructor(new[] { typeof(bool[]) })!); 3642ilg.Stloc(paramsRead); 3650LocalBuilder loc = ilg.DeclareLocal( 3656ilg.BeginExceptionBlock(); 3658ReflectionAwareILGen.ILGenForCreateInstance(ilg, mapping.TypeDesc.Type!, mapping.TypeDesc.CannotNew, true); 3659ilg.Stloc(loc); 3662ilg.Leave(); 3669ilg.Ldarg(0); 3670ilg.Ldstr(GetCSharpString(fullTypeName)); 3671ilg.Call(XmlSerializationReader_CreateInaccessibleConstructorException); 3672ilg.Throw(); 3680ilg.Ldarg(0); 3681ilg.Ldstr(GetCSharpString(fullTypeName)); 3682ilg.Call(XmlSerializationReader_CreateCtorHasSecurityException); 3683ilg.Throw(); 3685ilg.EndExceptionBlock(); 3691ilg.BeginCatchBlock(exceptionType); 3692ilg.Pop(); 3697ReflectionAwareILGen.WriteArrayLocalDecl(typeName, variableName, new SourceInfo(initValue, initValue, null, arrayTypeDesc.Type, ilg), arrayTypeDesc); 3702ReflectionAwareILGen.WriteCreateInstance(source, ctorInaccessible, type, ilg); 3741ilg.Ldarg(0); 3742ilg.Load(null); 3743ilg.Ldstr(match.Groups["qnames"].Value); 3744ilg.Call(XmlSerializationReader_UnknownNode2); 3751ilg.Ldarg(0); 3752LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3753ilg.Ldloc(localO); 3754ilg.ConvertValue(localO.LocalType, typeof(object)); 3755ilg.Ldstr(match.Groups["qnames"].Value); 3756ilg.Call(XmlSerializationReader_UnknownNode2); 3763ilg.Ldarg(0); 3764LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3765ilg.Ldloc(localO); 3766ilg.ConvertValue(localO.LocalType, typeof(object)); 3767ilg.Load(null); 3768ilg.Call(XmlSerializationReader_UnknownNode2); 3775ilg.Ldarg(0); 3776LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3777ilg.Ldloc(localO); 3778ilg.ConvertValue(localO.LocalType, typeof(object)); 3779ilg.Call(XmlSerializationReader_UnknownNode1); 3789ilg.Ldloca(ilg.GetLocal("paramsRead")); 3790ilg.Ldc(int.Parse(match.Groups["index"].Value, CultureInfo.InvariantCulture)); 3791ilg.Call(typeof(Span<bool>).GetMethod("get_Item")!); 3792ilg.LdindU1(); 3802ilg.Ldloca(ilg.GetLocal("paramsRead")); 3803ilg.Ldc(int.Parse(match.Groups["index"].Value, CultureInfo.InvariantCulture)); 3804ilg.Call(typeof(Span<bool>).GetMethod("get_Item")!); 3805ilg.Ldc(value); 3806ilg.StindI1(); 3820ilg.Ldarg(0); 3821ilg.Call(XmlSerializationReader_CreateUnknownNodeException); 3822ilg.Throw(); 3836ilg.Load(value);

89ilg.BeginMethod(typeof(void), "InitCallbacks", Type.EmptyTypes, Array.Empty<string>(), 91ilg.EndMethod(); 102ilg.Ldarg(0); 103ilg.Ldstr(GetCSharpString(name)); 107ilg.Ldstr(GetCSharpString(ns)); 118ilg.Call(XmlSerializationWriter_WriteXXX); 137ilg.Ldarg(0); 139ilg.Call(methodBuilder); 167ilg.Call(XmlConvert_ToString); 177ilg.Ldarg(0); 185ilg.Call(FromXXX); 222ilg.Ldc(Enum.Parse(mapping.TypeDesc.Type!, enumDefaultValue!, false)); 223ilg.If(Cmp.NotEqualTo); // " != " 231ilg.Ldarg(0); 233ilg.Ldstr(GetCSharpString(name)); 237ilg.Ldstr(GetCSharpString(ns)); 259ilg.Ldstr(GetCSharpString(mapping.TypeName)); 260ilg.Ldstr(GetCSharpString(mapping.Namespace)); 261ilg.New(XmlQualifiedName_ctor); 269ilg.Call(XmlSerializationWriter_method); 273ilg.EndIf(); 284ilg.Ldarg(0); 285ilg.Ldstr(GetCSharpString(name)); 286ilg.Ldstr(GetCSharpString(ns)); 287ilg.Call(XmlSerializationWriter_Method); 297ilg.Ldarg(0); 298ilg.Ldstr(GetCSharpString(name)); 299ilg.Ldstr(GetCSharpString(ns)); 300ilg.Load(null); 301ilg.Ldc(writePrefixed); 302ilg.Call(XmlSerializationWriter_Method); 317ilg.Ldarg(0); 318ilg.Call(XmlSerializationWriter_WriteEndElement); 327object oVar = ilg.GetVariable(source); 328ilg.Ldarg(0); 329ilg.Load(oVar); 330ilg.ConvertValue(CodeGenerator.GetVariableType(oVar), typeof(object)); 331ilg.Call(XmlSerializationWriter_WriteEndElement); 357ilg.BeginMethod( 370ilg.Ldarg(0); 371ilg.Call(XmlSerializationWriter_WriteStartDocument); 378ilg.Ldarg(0); 379ilg.Call(XmlSerializationWriter_TopLevelElement); 384LocalBuilder pLengthLoc = ilg.DeclareLocal(typeof(int), "pLength"); 385ilg.Ldarg("p"); 386ilg.Ldlen(); 387ilg.Stloc(pLengthLoc); 398ilg.Ldloc(pLengthLoc); 399ilg.Ldc(xmlnsMember); 400ilg.If(Cmp.GreaterThan); 402ilg.EndIf(); 411SourceInfo source = new SourceInfo($"p[{i}]", null, null, pLengthLoc.LocalType.GetElementType()!, ilg); 422specifiedSource = new SourceInfo($"((bool)p[{j}])", null, null, typeof(bool), ilg); 429ilg.Ldloc(pLengthLoc); 430ilg.Ldc(i); 431ilg.If(Cmp.GreaterThan); 435Label labelTrue = ilg.DefineLabel(); 436Label labelEnd = ilg.DefineLabel(); 437ilg.Ldloc(pLengthLoc); 438ilg.Ldc(specifiedPosition); 439ilg.Ble(labelTrue); 441ilg.Br_S(labelEnd); 442ilg.MarkLabel(labelTrue); 443ilg.Ldc(true); 444ilg.MarkLabel(labelEnd); 445ilg.If(); 452ilg.EndIf(); 455ilg.EndIf(); 478specifiedSource = new SourceInfo($"((bool)p[{j}])", null, null, typeof(bool), ilg); 485ilg.Ldloc(pLengthLoc); 486ilg.Ldc(i); 487ilg.If(Cmp.GreaterThan); 491Label labelTrue = ilg.DefineLabel(); 492Label labelEnd = ilg.DefineLabel(); 493ilg.Ldloc(pLengthLoc); 494ilg.Ldc(specifiedPosition); 495ilg.Ble(labelTrue); 497ilg.Br_S(labelEnd); 498ilg.MarkLabel(labelTrue); 499ilg.Ldc(true); 500ilg.MarkLabel(labelEnd); 501ilg.If(); 524WriteMember(new SourceInfo(source, source, null, null, ilg), enumSource, member.ElementsSortedByDerivation!, member.Text, member.ChoiceIdentifier, member.TypeDesc!, writeAccessors || hasWrapperElement); 528ilg.EndIf(); 531ilg.EndIf(); 538ilg.EndMethod(); 548ilg.BeginMethod( 561ilg.Ldarg(0); 562ilg.Call(XmlSerializationWriter_WriteStartDocument); 564ilg.If(ilg.GetArg("o"), Cmp.EqualTo, null); 571ilg.GotoMethodEnd(); 572ilg.EndIf(); 581ilg.Ldarg(0); 582ilg.Call(XmlSerializationWriter_TopLevelElement); 585WriteMember(new SourceInfo("o", "o", null, typeof(object), ilg), null, new ElementAccessor[] { element }, null, null, mapping.TypeDesc, true); 587ilg.EndMethod(); 605ilg.BeginMethod( 611LocalBuilder sLoc = ilg.DeclareLocal(typeof(string), "s"); 612ilg.Load(null); 613ilg.Stloc(sLoc); 621Label defaultLabel = ilg.DefineLabel(); 622Label endSwitchLabel = ilg.DefineLabel(); 624LocalBuilder localTmp = ilg.DeclareLocal(mapping.TypeDesc.Type!, "localTmp"); 625ilg.Ldarg("v"); 626ilg.Stloc(localTmp); 632Label caseLabel = ilg.DefineLabel(); 633ilg.Ldloc(localTmp); 634ilg.Ldc(Enum.ToObject(mapping.TypeDesc.Type!, c.Value)); 635ilg.Beq(caseLabel); 644ilg.Br(defaultLabel); 647ilg.MarkLabel(caseLabels[i]); 648ilg.Ldc(retValues[i]); 649ilg.Stloc(sLoc); 650ilg.Br(endSwitchLabel); 652ilg.MarkLabel(defaultLabel); 653ReflectionAwareILGen.ILGenForEnumLongValue(ilg, "v"); 654LocalBuilder strArray = ilg.DeclareLocal(typeof(string[]), "strArray"); 655ilg.NewArray(typeof(string), constants.Length); 656ilg.Stloc(strArray); 660ilg.Ldloc(strArray); 661ilg.Ldc(i); 662ilg.Ldstr(GetCSharpString(c.XmlName)); 663ilg.Stelem(typeof(string)); 665ilg.Ldloc(strArray); 666LocalBuilder longArray = ilg.DeclareLocal(typeof(long[]), "longArray"); 667ilg.NewArray(typeof(long), constants.Length); 668ilg.Stloc(longArray); 673ilg.Ldloc(longArray); 674ilg.Ldc(i); 675ilg.Ldc(c.Value); 676ilg.Stelem(typeof(long)); 678ilg.Ldloc(longArray); 679ilg.Ldstr(GetCSharpString(mapping.TypeDesc.FullName)); 685ilg.Call(XmlSerializationWriter_FromEnum); 686ilg.Stloc(sLoc); 687ilg.Br(endSwitchLabel); 691ilg.Br(defaultLabel); 695ilg.MarkLabel(caseLabels[i]); 696ilg.Ldc(retValues[i]); 697ilg.Stloc(sLoc); 698ilg.Br(endSwitchLabel); 716ilg.MarkLabel(defaultLabel); 717ilg.Ldarg(0); 718ilg.Ldarg("v"); 719ilg.ConvertValue(mapping.TypeDesc.Type!, typeof(long)); 720LocalBuilder numLoc = ilg.DeclareLocal(typeof(long), "num"); 721ilg.Stloc(numLoc); 723ilg.LdlocAddress(numLoc); 724ilg.Call(CultureInfo_get_InvariantCulture); 725ilg.Call(Int64_ToString); 726ilg.Ldstr(GetCSharpString(mapping.TypeDesc.FullName)); 727ilg.Call(XmlSerializationWriter_CreateInvalidEnumValueException); 728ilg.Throw(); 730ilg.MarkLabel(endSwitchLabel); 732ilg.Ldloc(sLoc); 733ilg.EndMethod(); 740ilg.InitElseIf(); 742ilg.AndIf(); 752ilg.Ldarg(0); 754ilg.Ldarg("n"); 756ilg.Ldarg("ns"); 757object oVar = ilg.GetVariable("o"); 759ilg.Load(oVar); 760ilg.ConvertValue(oType, derived.TypeDesc.Type!); 765ilg.Ldarg("isNullable"); 768ilg.Ldc(true); 774ilg.Call(methodBuilder); 775ilg.GotoMethodEnd(); 790ilg.InitElseIf(); 793ilg.AndIf(); 811ilg.Ldarg(0); 812ilg.Call(XmlSerializationWriter_get_Writer); 813ilg.Ldarg("n"); 814ilg.Ldarg("ns"); 815ilg.Call(XmlWriter_WriteStartElement); 821ilg.Ldarg(0); 822ilg.Ldstr(GetCSharpString(mapping.TypeName)); 823ilg.Ldstr(GetCSharpString(mapping.Namespace)); 824ilg.Call(XmlSerializationWriter_WriteXsiType); 836ilg.Ldarg(0); 837ilg.Call(XmlSerializationWriter_get_Writer); 838object oVar = ilg.GetVariable("o"); 839ilg.Ldarg(0); 840ilg.Load(oVar); 841ilg.ConvertValue(CodeGenerator.GetVariableType(oVar), mapping.TypeDesc.Type!); 842ilg.Call(methodBuilder); 843ilg.Call(XmlWriter_WriteString); 849ilg.Ldarg(0); 850ilg.Call(XmlSerializationWriter_get_Writer); 851ilg.Call(XmlWriter_WriteEndElement); 852ilg.GotoMethodEnd(); 858ilg.InitElseIf(); 864ilg.AndIf(); 865ilg.EnterScope(); 877ilg.Ldarg(0); 878ilg.Call(XmlSerializationWriter_get_Writer); 879ilg.Ldarg("n"); 880ilg.Ldarg("ns"); 881ilg.Call(XmlWriter_WriteStartElement); 887ilg.Ldarg(0); 888ilg.Ldstr(GetCSharpString(mapping.TypeName)); 889ilg.Ldstr(GetCSharpString(mapping.Namespace)); 890ilg.Call(XmlSerializationWriter_WriteXsiType); 892WriteMember(new SourceInfo("o", "o", null, null, ilg), null, mapping.ElementsSortedByDerivation!, null, null, mapping.TypeDesc, true); 899ilg.Ldarg(0); 900ilg.Call(XmlSerializationWriter_get_Writer); 901ilg.Call(XmlWriter_WriteEndElement); 902ilg.GotoMethodEnd(); 903ilg.ExitScope(); 930ilg.BeginMethod(typeof(void), 937ilg.If(ilg.GetArg("o"), Cmp.EqualTo, null); 939ilg.If(ilg.GetArg("isNullable"), Cmp.EqualTo, true); 946ilg.Ldarg(0); 947ilg.Ldarg("n"); 948ilg.Ldarg("ns"); 949ilg.Call(XmlSerializationWriter_WriteNullTagLiteral); 951ilg.EndIf(); 952ilg.GotoMethodEnd(); 954ilg.EndIf(); 956ilg.If(ilg.GetArg("needType"), Cmp.NotEqualTo, true); // if (!needType) 958LocalBuilder tLoc = ilg.DeclareLocal(typeof(Type), "t"); 964ArgBuilder oArg = ilg.GetArg("o"); 965ilg.LdargAddress(oArg); 966ilg.ConvertAddress(oArg.ArgType, typeof(object)); 967ilg.Call(Object_GetType); 968ilg.Stloc(tLoc); 971ilg.If(); // if (t == typeof(...)) 975ilg.Else(); 983ilg.Ldarg(0); 984ilg.Ldarg("n"); 985ilg.Ldarg("ns"); 986ilg.Ldarg("o"); 987ilg.Ldc(true); 988ilg.Call(XmlSerializationWriter_WriteTypedPrimitive); 989ilg.GotoMethodEnd(); 998ilg.Ldarg(0); 999ilg.Ldarg(oArg); 1000ilg.ConvertValue(oArg.ArgType, typeof(object)); 1001ilg.Call(XmlSerializationWriter_CreateUnknownTypeException); 1002ilg.Throw(); 1004ilg.EndIf(); // if (t == typeof(...)) 1005ilg.EndIf(); // if (!needType) 1016ilg.Ldarg(0); 1017ilg.Ldc(false); 1018ilg.Call(XmlSerializationWriter_set_EscapeName); 1031ilg.Ldarg(0); 1032ilg.Ldarg("n"); 1033ilg.Ldarg("ns"); 1034ArgBuilder argO = ilg.GetArg("o"); 1035ilg.Ldarg(argO); 1036ilg.ConvertValue(argO.ArgType, typeof(object)); 1037ilg.Ldc(false); 1039ilg.Load(null); 1051ilg.Call(XmlSerializationWriter_WriteStartElement); 1054ilg.If(ilg.GetArg("needType"), Cmp.EqualTo, true); 1061ilg.Ldarg(0); 1062ilg.Ldstr(GetCSharpString(mapping.TypeName)); 1063ilg.Ldstr(GetCSharpString(mapping.Namespace)); 1064ilg.Call(XmlSerializationWriter_WriteXsiType); 1066ilg.EndIf(); 1076ilg.LdargAddress(oArg); 1077ilg.Call(m.CheckShouldPersistMethodInfo!); 1078ilg.If(); 1084ilg.If(); 1086WriteMember(ReflectionAwareILGen.GetSourceForMember("o", m, ilg), m.Attribute, m.TypeDesc!, "o"); 1090ilg.EndIf(); 1094ilg.EndIf(); 1109ilg.LdargAddress(oArg); 1110ilg.Call(m.CheckShouldPersistMethodInfo!); 1111ilg.If(); 1117ilg.If(); 1127WriteMember(ReflectionAwareILGen.GetSourceForMember("o", m, m.MemberInfo, ilg), choiceSource, m.ElementsSortedByDerivation!, m.Text, m.ChoiceIdentifier, m.TypeDesc!, true); 1131ilg.EndIf(); 1135ilg.EndIf(); 1140ilg.EndMethod(); 1161ilg.EnterScope(); 1165ilg.Ldloc(memberTypeDesc.Type!, aVar); 1166ilg.Load(null); 1167ilg.If(Cmp.NotEqualTo); 1184ilg.Ldarg(0); 1185ilg.Call(XmlSerializationWriter_get_Writer); 1186ilg.Load(null); 1187ilg.Ldstr(GetCSharpString(attribute.Name)); 1188ilg.Ldstr(GetCSharpString(ns)); 1189ilg.Call(XmlWriter_WriteStartAttribute); 1193LocalBuilder sbLoc = ilg.DeclareOrGetLocal(typeof(StringBuilder), "sb"); 1198ilg.New(StringBuilder_ctor); 1199ilg.Stloc(sbLoc); 1210LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(int), iVar); 1211ilg.For(localI, 0, ilg.GetLocal(aVar)); 1222ilg.Ldloc(iVar); 1223ilg.Ldc(0); 1224ilg.If(Cmp.NotEqualTo); 1235ilg.Ldarg(0); 1236ilg.Call(XmlSerializationWriter_get_Writer); 1237ilg.Ldstr(" "); 1238ilg.Call(XmlWriter_WriteString); 1239ilg.EndIf(); 1240ilg.Ldarg(0); 1251ilg.Ldloc(iVar); 1252ilg.Ldc(0); 1253ilg.If(Cmp.NotEqualTo); 1254ilg.Ldloc("sb"); 1255ilg.Ldstr(" "); 1256ilg.Call(StringBuilder_Append); 1257ilg.Pop(); 1258ilg.EndIf(); 1259ilg.Ldloc("sb"); 1264WriteEnumValue((EnumMapping)attribute.Mapping, new SourceInfo(aiVar, aiVar, null, arrayElementTypeDesc.Type, ilg), out argType); 1266WritePrimitiveValue(arrayElementTypeDesc, new SourceInfo(aiVar, aiVar, null, arrayElementTypeDesc.Type, ilg), out argType); 1272ilg.Call(method); 1274ilg.Pop(); 1278WriteAttribute(new SourceInfo(aiVar, aiVar, null, null, ilg), attribute, parent); 1283ilg.EndFor(); 1299ilg.Ldarg(0); 1300ilg.Call(XmlSerializationWriter_get_Writer); 1301ilg.Call(XmlWriter_WriteEndAttribute); 1310ilg.Ldloc("sb"); 1311ilg.Call(StringBuilder_get_Length); 1312ilg.Ldc(0); 1313ilg.If(Cmp.NotEqualTo); 1316ilg.Ldarg(0); 1317ilg.Ldstr(GetCSharpString(attribute.Name)); 1322ilg.Ldstr(GetCSharpString(ns)); 1330ilg.Ldloc("sb"); 1331ilg.Call(Object_ToString); 1338ilg.Call(XmlSerializationWriter_WriteAttribute); 1339ilg.EndIf(); 1345ilg.EndIf(); 1348ilg.ExitScope(); 1368ilg.Ldarg(0); 1369ilg.Ldloc(source.Source); 1370ilg.Ldarg(parent); 1371ilg.ConvertValue(ilg.GetArg(parent).ArgType, typeof(object)); 1372ilg.Call(XmlSerializationWriter_WriteXmlAttribute); 1419ilg.EnterScope(); 1421LocalBuilder aLoc = ilg.GetLocal(aName); 1424ilg.Ldloc(aLoc); 1425ilg.Load(null); 1426ilg.If(Cmp.NotEqualTo); 1433SourceInfo choiceSourceInfo = new SourceInfo(choiceSource!, null, choice.MemberInfo, null, ilg); 1437Label labelEnd = ilg.DefineLabel(); 1438Label labelTrue = ilg.DefineLabel(); 1439LocalBuilder cLoc = ilg.GetLocal(cName); 1440ilg.Ldloc(cLoc); 1441ilg.Load(null); 1442ilg.Beq(labelTrue); 1443ilg.Ldloc(cLoc); 1444ilg.Ldlen(); 1445ilg.Ldloc(aLoc); 1446ilg.Ldlen(); 1447ilg.Clt(); 1448ilg.Br(labelEnd); 1449ilg.MarkLabel(labelTrue); 1450ilg.Ldc(true); 1451ilg.MarkLabel(labelEnd); 1452ilg.If(); 1458ilg.Ldarg(0); 1459ilg.Ldstr(GetCSharpString(choice.Mapping.TypeDesc.FullName)); 1460ilg.Ldstr(GetCSharpString(choice.MemberName)); 1461ilg.Call(XmlSerializationWriter_CreateInvalidChoiceIdentifierValueException); 1462ilg.Throw(); 1463ilg.EndIf(); 1469ilg.EndIf(); 1472ilg.ExitScope(); 1485LocalBuilder eLoc = ilg.DeclareLocal(typeof(IEnumerator), "e"); 1486ilg.LoadAddress(ilg.GetVariable(arrayName)); 1498ilg.ConvertValue(arrayTypeDesc.Type!, typeIEnumerable); 1509ilg.ConvertValue(arrayTypeDesc.Type!, typeIEnumerable); 1517ilg.Call(getEnumeratorMethod); 1518ilg.ConvertValue(getEnumeratorMethod.ReturnType, typeof(IEnumerator)); 1519ilg.Stloc(eLoc); 1524sepLoc = ilg.DeclareOrGetLocal(typeof(bool), $"{arrayName}NeedsSep"); 1525ilg.Ldc(false); 1526ilg.Stloc(sepLoc); 1529ilg.Ldloc(eLoc); 1530ilg.Load(null); 1531ilg.If(Cmp.NotEqualTo); 1532ilg.WhileBegin(); 1538ilg.Ldloc(sepLoc!); 1539ilg.If(); 1541ilg.EndIf(); 1542ilg.Ldc(true); 1543ilg.Stloc(sepLoc!); 1545WriteElements(new SourceInfo(arrayNamePlusI, null, null, arrayElementTypeDesc.Type, ilg), $"{choiceName}i", elements, text, choice, arrayNamePlusA, true, true); 1547ilg.WhileBeginCondition(); // while (e.MoveNext()) 1552ilg.Ldloc(eLoc); 1553ilg.Call(IEnumerator_MoveNext); 1554ilg.WhileEndCondition(); 1555ilg.WhileEnd(); 1557ilg.EndIf(); // if (e != null) 1565LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(int), iPlusArrayName); 1566ilg.For(localI, 0, ilg.GetLocal(arrayName)); 1575WriteElements(new SourceInfo(arrayNamePlusI, null, null, arrayElementTypeDesc.Type, ilg), $"{choiceName}i", elements, text, choice, arrayNamePlusA, true, arrayElementTypeDesc.IsNullable); 1581ilg.Ldloc(localI); 1582ilg.Ldc(0); 1583ilg.If(Cmp.NotEqualTo); 1585ilg.EndIf(); 1587WriteElements(new SourceInfo(ReflectionAwareILGen.GetStringForArrayMember(arrayName, iPlusArrayName), null, null, arrayElementTypeDesc.Type, ilg), null, elements, text, choice, arrayNamePlusA, true, arrayElementTypeDesc.IsNullable); 1589ilg.EndFor(); 1602ilg.Ldarg(0); 1603ilg.Ldstr(" "); 1604ilg.Call(XmlSerializationWriter_WriteValue); 1623ilg.Load(null); 1624ilg.If(Cmp.NotEqualTo); 1654if (wroteFirstIf) ilg.InitElseIf(); 1655else { wroteFirstIf = true; ilg.InitIf(); } 1657ilg.Load(enumValue); 1658ilg.Ceq(); 1661Label labelFalse = ilg.DefineLabel(); 1662Label labelEnd = ilg.DefineLabel(); 1663ilg.Brfalse(labelFalse); 1665ilg.Load(null); 1666ilg.Cne(); 1667ilg.Br_S(labelEnd); 1668ilg.MarkLabel(labelFalse); 1669ilg.Ldc(false); 1670ilg.MarkLabel(labelEnd); 1672ilg.AndIf(); 1682if (wroteFirstIf) ilg.InitElseIf(); 1683else { wroteFirstIf = true; ilg.InitIf(); } 1686ilg.AndIf(); 1699else ilg.EndIf(); 1704if (elements.Length - anyCount > 0) ilg.InitElseIf(); 1705else ilg.InitIf(); 1708ilg.IsInst(typeof(XmlElement)); 1709ilg.Load(null); 1710ilg.Cne(); 1711ilg.AndIf(); 1713LocalBuilder elemLoc = ilg.DeclareLocal(typeof(XmlElement), "elem"); 1715ilg.Stloc(elemLoc); 1721if (c++ > 0) ilg.InitElseIf(); 1722else ilg.InitIf(); 1731labelFalse = ilg.DefineLabel(); 1732labelEnd = ilg.DefineLabel(); 1734ilg.Load(enumValue); 1735ilg.Bne(labelFalse); 1739ilg.Load(null); 1740ilg.Cne(); 1744ilg.Ldc(true); 1746ilg.Br(labelEnd); 1747ilg.MarkLabel(labelFalse); 1748ilg.Ldc(false); 1749ilg.MarkLabel(labelEnd); 1750ilg.AndIf(); 1752labelFalse = ilg.DefineLabel(); 1753labelEnd = ilg.DefineLabel(); 1764ilg.Ldloc(elemLoc); 1765ilg.Call(XmlNode_get_Name); 1766ilg.Ldstr(GetCSharpString(element.Name)); 1772ilg.Call(String_op_Equality); 1773ilg.Brfalse(labelFalse); 1774ilg.Ldloc(elemLoc); 1775ilg.Call(XmlNode_get_NamespaceURI); 1776ilg.Ldstr(GetCSharpString(element.Namespace)); 1777ilg.Call(String_op_Equality); 1778ilg.Br(labelEnd); 1779ilg.MarkLabel(labelFalse); 1780ilg.Ldc(false); 1781ilg.MarkLabel(labelEnd); 1782if (choice != null) ilg.If(); 1783else ilg.AndIf(); 1784WriteElement(new SourceInfo("elem", null, null, elemLoc.LocalType, ilg), element, arrayName, writeAccessors); 1788ilg.Else(); 1795ilg.Ldarg(0); 1796ilg.Ldstr(GetCSharpString(enumFullName)); 1797ilg.Ldstr(GetCSharpString(choice.MemberName)); 1798ilg.Ldloc(elemLoc); 1799ilg.Call(XmlNode_get_Name); 1800ilg.Ldloc(elemLoc); 1801ilg.Call(XmlNode_get_NamespaceURI); 1802ilg.Call(XmlSerializationWriter_CreateChoiceIdentifierValueException); 1803ilg.Throw(); 1804ilg.EndIf(); 1809ilg.Else(); 1813WriteElement(new SourceInfo("elem", null, null, elemLoc.LocalType, ilg), unnamedAny, arrayName, writeAccessors); 1822ilg.Ldarg(0); 1823ilg.Ldloc(elemLoc); 1834ilg.Call(XmlNode_get_Name); 1835ilg.Ldloc(elemLoc); 1836ilg.Call(XmlNode_get_NamespaceURI); 1837ilg.Call(XmlSerializationWriter_CreateUnknownAnyElementException); 1838ilg.Throw(); 1842ilg.EndIf(); 1849ilg.InitElseIf(); 1851ilg.AndIf(); 1865ilg.InitElseIf(); 1867ilg.Load(null); 1868ilg.AndIf(Cmp.NotEqualTo); 1872ilg.Else(); 1879ilg.Ldarg(0); 1881ilg.Call(XmlSerializationWriter_CreateUnknownTypeException); 1882ilg.Throw(); 1884ilg.EndIf(); 1888ilg.EndIf(); 1897ilg.Ldarg(0); 1911ilg.Call(XmlSerializationWriter_WriteValue); 1929ilg.Ldarg(0); 1930ilg.Call(XmlSerializationWriter_get_Writer); 1931ilg.Call(WriteTo); 1953ilg.Call(Nullable_get_HasValue); 1958ilg.Load(null); 1959ilg.Cne(); 1961ilg.If(); 1968ilg.Else(); 1971ilg.EndIf(); 1981ilg.EnterScope(); 1992ilg.Ldloc(ilg.GetLocal(arrayName)); 1993ilg.Load(null); 1994ilg.If(Cmp.NotEqualTo); 2002ilg.EndIf(); 2008ilg.EndIf(); 2011ilg.ExitScope(); 2040ilg.Ldarg(0); 2041ilg.Ldstr(GetCSharpString(name)); 2043ilg.Ldstr(GetCSharpString(ns)); 2049ilg.Ldc(element.IsNullable); 2052ilg.Ldc(false); 2059ilg.Call(methodBuilder); 2070Label ifLabel1 = ilg.DefineLabel(); 2071Label ifLabel2 = ilg.DefineLabel(); 2073ilg.IsInst(typeof(XmlNode)); 2074ilg.Brtrue(ifLabel1); 2076ilg.Load(null); 2077ilg.Ceq(); 2078ilg.Br(ifLabel2); 2079ilg.MarkLabel(ifLabel1); 2080ilg.Ldc(true); 2081ilg.MarkLabel(ifLabel2); 2082ilg.If(); 2086ilg.Else(); 2093ilg.Ldarg(0); 2095ilg.Call(XmlSerializationWriter_CreateInvalidAnyTypeException); 2096ilg.Throw(); 2098ilg.EndIf(); 2114ilg.Ldarg(0); 2116ilg.Ldstr(GetCSharpString(name)); 2117ilg.Ldstr(GetCSharpString(ns)); 2118ilg.Ldc(isNullable); 2119ilg.Ldc(isAny); 2120ilg.Call(XmlSerializationWriter_func); 2128Label labelEnd = ilg.DefineLabel(); 2129Label labelFalse = ilg.DefineLabel(); 2130Label labelTrue = ilg.DefineLabel(); 2134ilg.Brfalse(labelTrue); 2137ilg.Brfalse(labelFalse); 2144ilg.Call(String_get_Length); 2145ilg.Ldc(0); 2146ilg.Cne(); 2147ilg.Br(labelEnd); 2150ilg.MarkLabel(labelTrue); 2151ilg.Ldc(true); 2155ilg.MarkLabel(labelFalse); 2156ilg.Ldc(false); 2158ilg.MarkLabel(labelEnd); 2159ilg.If(); 2166ilg.Load(null); 2167ilg.Cne(); 2172ilg.Ldc(Convert.ChangeType(value, source.Type!, CultureInfo.InvariantCulture)); 2173ilg.Cne(); 2179ilg.Ldc(value is string ? GetCSharpString((string)value) : value); 2186ilg.Call(op_Inequality); 2188ilg.Cne(); 2190ilg.If(); 2196Label labelFalse = ilg.DefineLabel(); 2197Label labelEnd = ilg.DefineLabel(); 2199ilg.Load(null); 2200ilg.Beq(labelFalse); 2203ilg.Ldc(false); 2204ilg.Ceq(); 2205ilg.Br(labelEnd); 2206ilg.MarkLabel(labelFalse); 2207ilg.Ldc(false); 2208ilg.MarkLabel(labelEnd); 2209ilg.If(); 2215ilg.Ldarg(0); 2216ilg.Ldstr(GetCSharpString(typeDesc.FullName)); 2217ilg.Ldstr(GetCSharpString(choice.MemberName)); 2218ilg.Ldstr(GetCSharpString(enumName)); 2219ilg.Call(XmlSerializationWriter_CreateMismatchChoiceException); 2220ilg.Throw(); 2221ilg.EndIf(); 2226LocalBuilder local = ilg.GetLocal(source); 2228ilg.Load(local); 2229ilg.Load(null); 2230ilg.If(Cmp.EqualTo); 2232ilg.Else(); 2242ilg.Ldarg(0); 2244ilg.Call(XmlSerializationWriter_WriteNamespaceDeclarations); 2260ReflectionAwareILGen.WriteLocalDecl(variableName, new SourceInfo(initValue, initValue, null, type, ilg)); 2269ReflectionAwareILGen.WriteTypeCompare(variable, type, ilg); 2274ReflectionAwareILGen.WriteInstanceOf(source, type, ilg); 2278ReflectionAwareILGen.WriteArrayTypeCompare(variable, arrayType, ilg);