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);

227ilg = new CodeGenerator(this.typeBuilder); 342ilg = new CodeGenerator(this.typeBuilder); 388ilg = new CodeGenerator(this.typeBuilder); 631ilg = new CodeGenerator(this.typeBuilder); 960ilg = new CodeGenerator(this.typeBuilder); 1032ilg = new CodeGenerator(this.typeBuilder); 1277ilg = new CodeGenerator(this.typeBuilder); 1328ilg = 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!);

228ilg.BeginMethod(typeof(void), "InitIDs", Type.EmptyTypes, Array.Empty<string>(), 247ilg.Ldarg(0); 248ilg.Ldarg(0); 249ilg.Call(XmlSerializationReader_get_Reader); 250ilg.Call(XmlReader_get_NameTable); 251ilg.Ldstr(GetCSharpString(id)); 252ilg.Call(XmlNameTable_Add); 254ilg.StoreMember(_idNameFields[id]); 256ilg.EndMethod(); 292ilg.Ldarg(0); 293ilg.Call(XmlSerializationReader_get_Reader); 294ilg.Ldarg(0); 295ilg.LoadMember(_idNameFields[name ?? string.Empty]); 296ilg.Ldarg(0); 297ilg.LoadMember(_idNameFields[ns ?? string.Empty]); 298ilg.Call(XmlReader_IsStartElement); 299ilg.If(); 306ilg.Else(); 309ilg.Ldarg(0); 312ilg.Load(null); 315object pVar = ilg.GetVariable("p"); 316ilg.Load(pVar); 317ilg.ConvertValue(CodeGenerator.GetVariableType(pVar), typeof(object)); 325ilg.Ldstr(ReflectionAwareILGen.GetCSharpString(expectedElement)); 333ilg.Call(method); 336ilg.EndIf(); 343ilg.BeginMethod(typeof(void), "InitCallbacks", Type.EmptyTypes, Array.Empty<string>(), 345ilg.EndMethod(); 389ilg.BeginMethod( 396ilg.Load(null); 397ilg.Stloc(ilg.ReturnLocal); 408ilg.Ldarg(0); 409ilg.Call(XmlSerializationReader_get_Reader); 410ilg.Call(XmlReader_MoveToContent); 411ilg.Pop(); 413LocalBuilder localP = ilg.DeclareLocal(typeof(object[]), "p"); 414ilg.NewArray(typeof(object), mappings.Length); 415ilg.Stloc(localP); 505ilg.Ldarg(0); 506ilg.Ldc(true); 507ilg.Call(XmlSerializationReader_set_IsReturnValue); 523ilg.Ldarg(0); 524ilg.Call(XmlSerializationReader_get_Reader); 525ilg.Call(XmlReader_MoveToElement); 526ilg.Pop(); 538ilg.Ldarg(0); 539ilg.Call(XmlSerializationReader_get_Reader); 540ilg.Call(XmlReader_get_IsEmptyElement); 541ilg.If(); 548ilg.Ldarg(0); 549ilg.Call(XmlSerializationReader_get_Reader); 550ilg.Call(XmlReader_Skip); 551ilg.Ldarg(0); 552ilg.Call(XmlSerializationReader_get_Reader); 553ilg.Call(XmlReader_MoveToContent); 554ilg.Pop(); 555ilg.WhileContinue(); 557ilg.EndIf(); 563ilg.Ldarg(0); 564ilg.Call(XmlSerializationReader_get_Reader); 565ilg.Call(XmlReader_ReadStartElement); 569ilg.Ldc(0); 570ilg.Stloc(typeof(int), "state"); 577ilg.Ldarg(0); 578ilg.Call(XmlSerializationReader_get_Reader); 579ilg.Call(XmlReader_MoveToContent); 580ilg.Pop(); 592ilg.Ldarg(0); 593ilg.Call(XmlSerializationReader_ReadEndElement); 598ilg.Ldarg(0); 599ilg.Call(XmlSerializationReader_get_Reader); 600ilg.Call(XmlReader_MoveToContent); 601ilg.Pop(); 605ilg.Ldloc(ilg.GetLocal("p")); 606ilg.EndMethod(); 617LocalBuilder arrayLoc = ilg.GetLocal(arrayName); 618ilg.Ldloc(arrayLoc); 619ilg.Ldc(i); 620ReflectionAwareILGen.ILGenForCreateInstance(ilg, mappings[i].TypeDesc!.Type!, false, false); 621ilg.ConvertValue(mappings[i].TypeDesc!.Type!, typeof(object)); 622ilg.Stelem(arrayLoc.LocalType.GetElementType()!); 632ilg.BeginMethod( 639LocalBuilder oLoc = ilg.DeclareLocal(typeof(object), "o"); 640ilg.Load(null); 641ilg.Stloc(oLoc); 657ilg.Ldarg(0); 658ilg.Call(XmlSerializationReader_get_Reader); 659ilg.Call(XmlReader_MoveToContent); 660ilg.Pop(); 663ilg.Ldloc(oLoc); 665ilg.Stloc(ilg.ReturnLocal); 666ilg.Ldloc(ilg.ReturnLocal); 667ilg.EndMethod(); 693ilg.Ldarg(0); 706ilg.Ldarg(0); 707ilg.Call(XmlSerializationReader_get_Reader); 708ilg.Call(XmlReader_ReadXXXString); 722ilg.Ldarg(0); 723ilg.Call(XmlSerializationReader_get_Reader); 724ilg.Call(XmlReader_get_Value); 728LocalBuilder locVals = ilg.GetLocal("vals"); 729LocalBuilder locI = ilg.GetLocal("i"); 730ilg.LoadArrayElement(locVals, locI); 734ilg.Ldc(false); 740ilg.Call(methodBuilder); 756ilg.Ldarg(0); 757ilg.Call(XmlSerializationReader_get_Reader); 758ilg.Call(XmlReader_ReadXXXString); 772ilg.Ldarg(0); 773ilg.Call(XmlSerializationReader_get_Reader); 774ilg.Call(XmlReader_get_Value); 778LocalBuilder locVals = ilg.GetLocal("vals"); 779LocalBuilder locI = ilg.GetLocal("i"); 780ilg.LoadArrayElement(locVals, locI); 793ilg.Ldarg(0); 794LocalBuilder locVals = ilg.GetLocal("vals"); 795LocalBuilder locI = ilg.GetLocal("i"); 796ilg.LoadArrayElement(locVals, locI); 806ilg.Call(XmlSerializationReader_CollapseWhitespace); 822ilg.Ldarg(0); 823ilg.Ldarg(0); 824ilg.Call(XmlSerializationReader_get_Reader); 825ilg.Call(XmlReader_method); 833ilg.Call(XmlSerializationReader_CollapseWhitespace); 850ilg.Ldarg(0); 879ilg.Ldarg(0); 880ilg.Call(XmlSerializationReader_get_Reader); 881ilg.Call(XmlReader_ReadXXXString); 895ilg.Ldarg(0); 896ilg.Call(XmlSerializationReader_get_Reader); 897ilg.Call(XmlReader_get_Value); 901LocalBuilder locVals = ilg.GetLocal("vals"); 902LocalBuilder locI = ilg.GetLocal("i"); 903ilg.LoadArrayElement(locVals, locI); 908ilg.Ldc(false); 910ilg.Call(ToXXX); 961ilg.BeginMethod( 968ilg.Ldarg(0); 969ilg.LoadMember(fieldBuilder); 970ilg.Load(null); 971ilg.If(Cmp.EqualTo); 977LocalBuilder hLoc = ilg.DeclareLocal(typeof(Hashtable), "h"); 978ilg.New(Hashtable_ctor); 979ilg.Stloc(hLoc); 990ilg.Ldloc(hLoc); 991ilg.Ldstr(GetCSharpString(constants[i].XmlName)); 992ilg.Ldc(Enum.ToObject(mapping.TypeDesc!.Type!, constants[i].Value)); 993ilg.ConvertValue(mapping.TypeDesc.Type!, typeof(long)); 994ilg.ConvertValue(typeof(long), typeof(object)); 996ilg.Call(Hashtable_Add); 999ilg.Ldarg(0); 1000ilg.Ldloc(hLoc); 1001ilg.StoreMember(fieldBuilder); 1003ilg.EndIf(); 1005ilg.Ldarg(0); 1006ilg.LoadMember(fieldBuilder); 1008get_TableName = ilg.EndMethod(); 1033ilg.BeginMethod( 1049ilg.Ldarg("s"); 1050ilg.Ldarg(0); 1052ilg.Call(get_TableName); 1053ilg.Ldstr(GetCSharpString(fullTypeName)); 1054ilg.Call(XmlSerializationReader_ToEnum); 1058ilg.ConvertValue(typeof(long), underlyingType); 1060ilg.Stloc(ilg.ReturnLocal); 1061ilg.Br(ilg.ReturnLabel); 1068Label defaultLabel = ilg.DefineLabel(); 1069Label endSwitchLabel = ilg.DefineLabel(); 1071LocalBuilder localTmp = ilg.GetTempLocal(typeof(string)); 1072ilg.Ldarg("s"); 1073ilg.Stloc(localTmp); 1074ilg.Ldloc(localTmp); 1075ilg.Brfalse(defaultLabel); 1084Label caseLabel = ilg.DefineLabel(); 1085ilg.Ldloc(localTmp); 1086ilg.Ldstr(GetCSharpString(c.XmlName)); 1092ilg.Call(String_op_Equality); 1093ilg.Brtrue(caseLabel); 1099ilg.Br(defaultLabel); 1103ilg.MarkLabel(caseLabels[i]); 1104ilg.Ldc(retValues[i]); 1105ilg.Stloc(ilg.ReturnLocal); 1106ilg.Br(ilg.ReturnLabel); 1114ilg.MarkLabel(defaultLabel); 1115ilg.Ldarg(0); 1116ilg.Ldarg("s"); 1118ilg.Ldc(mapping.TypeDesc.Type!); 1119ilg.Call(XmlSerializationReader_CreateUnknownConstantException); 1120ilg.Throw(); 1122ilg.MarkLabel(endSwitchLabel); 1125ilg.MarkLabel(ilg.ReturnLabel); 1126ilg.Ldloc(ilg.ReturnLocal); 1127ilg.EndMethod(); 1134ilg.InitElseIf(); 1136ilg.AndIf(); 1145ilg.Ldarg(0); 1148ilg.Ldarg("isNullable"); 1151ilg.Ldc(false); 1160ilg.Call(methodBuilder); 1161ilg.ConvertValue(methodBuilder.ReturnType, ilg.ReturnLocal.LocalType); 1162ilg.Stloc(ilg.ReturnLocal); 1163ilg.Br(ilg.ReturnLabel); 1177ilg.InitElseIf(); 1179ilg.AndIf(); 1190ilg.Ldarg(0); 1191ilg.Call(XmlSerializationReader_get_Reader); 1192ilg.Call(XmlReader_ReadStartElement); 1198LocalBuilder eLoc = ilg.DeclareOrGetLocal(typeof(object), "e"); 1215ilg.Ldarg(0); 1216ilg.Ldarg(0); 1217ilg.Ldarg(0); 1218ilg.Call(XmlSerializationReader_get_Reader); 1219ilg.Call(XmlReader_ReadString); 1220ilg.Call(XmlSerializationReader_CollapseWhitespace); 1221ilg.Call(methodBuilder); 1222ilg.ConvertValue(methodBuilder.ReturnType, eLoc.LocalType); 1223ilg.Stloc(eLoc); 1229ilg.Ldarg(0); 1230ilg.Call(XmlSerializationReader_ReadEndElement); 1231ilg.Ldloc(eLoc); 1232ilg.Stloc(ilg.ReturnLocal); 1233ilg.Br(ilg.ReturnLabel); 1240ilg.InitElseIf(); 1242ilg.AndIf(); 1243ilg.EnterScope(); 1252LocalBuilder aLoc = ilg.DeclareLocal(arrayMapping.TypeDesc.Type!, aVar); 1255ReflectionAwareILGen.ILGenForCreateInstance(ilg, td.Type!, false, false); 1258ilg.Load(null); 1259ilg.Stloc(aLoc); 1262ilg.Ldloc(aLoc); 1263ilg.Stloc(ilg.ReturnLocal); 1264ilg.Br(ilg.ReturnLabel); 1265ilg.ExitScope(); 1278ilg.BeginMethod( 1285LocalBuilder oLoc = ilg.DeclareLocal(nullableMapping.TypeDesc.Type!, "o"); 1287ilg.LoadAddress(oLoc); 1288ilg.InitObj(nullableMapping.TypeDesc.Type!); 1293ilg.Ldarg(0); 1294ilg.Call(XmlSerializationReader_ReadNull); 1295ilg.If(); 1297ilg.Ldloc(oLoc); 1298ilg.Stloc(ilg.ReturnLocal); 1299ilg.Br(ilg.ReturnLabel); 1301ilg.EndIf(); 1309ilg.Ldloc(oLoc); 1310ilg.Stloc(ilg.ReturnLocal); 1311ilg.Br(ilg.ReturnLabel); 1313ilg.MarkLabel(ilg.ReturnLabel); 1314ilg.Ldloc(ilg.ReturnLocal); 1315ilg.EndMethod(); 1338ilg.BeginMethod( 1345LocalBuilder locXsiType = ilg.DeclareLocal(typeof(XmlQualifiedName), "xsiType"); 1346LocalBuilder locIsNull = ilg.DeclareLocal(typeof(bool), "isNull"); 1357Label labelTrue = ilg.DefineLabel(); 1358Label labelEnd = ilg.DefineLabel(); 1359ilg.Ldarg("checkType"); 1360ilg.Brtrue(labelTrue); 1361ilg.Load(null); 1362ilg.Br_S(labelEnd); 1363ilg.MarkLabel(labelTrue); 1364ilg.Ldarg(0); 1365ilg.Call(XmlSerializationReader_GetXsiType); 1366ilg.MarkLabel(labelEnd); 1367ilg.Stloc(locXsiType); 1368ilg.Ldc(false); 1369ilg.Stloc(locIsNull); 1372ilg.Ldarg("isNullable"); 1373ilg.If(); 1375ilg.Ldarg(0); 1376ilg.Call(XmlSerializationReader_ReadNull); 1377ilg.Stloc(locIsNull); 1379ilg.EndIf(); 1382ilg.Ldarg("checkType"); 1383ilg.If(); // if (checkType) 1386ilg.Ldloc(locIsNull); 1387ilg.If(); 1388ilg.Ldloc(locXsiType); 1389ilg.Load(null); 1390ilg.If(Cmp.NotEqualTo); 1396ilg.Ldarg(0); 1397ilg.Ldloc(locXsiType); 1398ilg.Call(XmlSerializationReader_ReadTypedNull); 1399ilg.Stloc(ilg.ReturnLocal); 1400ilg.Br(ilg.ReturnLabel); 1401ilg.Else(); 1408ilg.Load(null); 1409ilg.Stloc(ilg.ReturnLocal); 1410ilg.Br(ilg.ReturnLabel); 1412ilg.EndIf(); // if (xsiType != null) 1414ilg.EndIf(); // if (isNull) 1416ilg.Ldloc(typeof(XmlQualifiedName), "xsiType"); 1417ilg.Load(null); 1418ilg.Ceq(); 1421labelTrue = ilg.DefineLabel(); 1422labelEnd = ilg.DefineLabel(); 1424ilg.Brtrue(labelTrue); 1427ilg.Br_S(labelEnd); 1428ilg.MarkLabel(labelTrue); 1429ilg.Ldc(true); 1430ilg.MarkLabel(labelEnd); 1432ilg.If(); // if (xsiType == null 1444ilg.Ldarg(0); 1445ilg.Ldstr(Soap.UrType); 1446ilg.Ldstr(XmlSchema.Namespace); 1447ilg.New(XmlQualifiedName_ctor); 1448ilg.Call(XmlSerializationReader_ReadTypedPrimitive); 1449ilg.Stloc(ilg.ReturnLocal); 1450ilg.Br(ilg.ReturnLabel); 1454ilg.Else(); // if (xsiType == null 1462ilg.Ldarg(0); 1463ilg.Ldloc(locXsiType); 1464ilg.Call(XmlSerializationReader_ReadTypedPrimitive); 1465ilg.Stloc(ilg.ReturnLocal); 1466ilg.Br(ilg.ReturnLabel); 1475ilg.Ldarg(0); 1476ilg.Ldloc(locXsiType); 1477ilg.Call(XmlSerializationReader_CreateUnknownTypeException); 1478ilg.Throw(); 1480ilg.EndIf(); // if (xsiType == null 1481ilg.EndIf(); // checkType 1485ilg.Ldloc(typeof(bool), "isNull"); 1486ilg.If(); 1488ilg.Load(null); 1489ilg.Stloc(ilg.ReturnLocal); 1490ilg.Br(ilg.ReturnLabel); 1492ilg.EndIf(); 1502ilg.Ldarg(0); 1503ilg.Ldstr(GetCSharpString(structMapping.TypeName)); 1504ilg.Ldstr(GetCSharpString(structMapping.Namespace)); 1505ilg.Call(XmlSerializationReader_CreateAbstractTypeException); 1506ilg.Throw(); 1517ilg.Ldarg(0); 1518ilg.Ldc(false); 1519ilg.Call(XmlSerializationReader_set_DecodeName); 1522LocalBuilder oLoc = ilg.GetLocal("o"); 1621ilg.Ldarg(0); 1622ilg.Call(XmlSerializationReader_get_Reader); 1623ilg.Call(XmlReader_MoveToElement); 1624ilg.Pop(); 1631ilg.Ldarg(0); 1632ilg.Call(XmlSerializationReader_get_Reader); 1633ilg.Call(XmlReader_get_IsEmptyElement); 1634ilg.If(); 1640ilg.Ldarg(0); 1641ilg.Call(XmlSerializationReader_get_Reader); 1642ilg.Call(XmlReader_Skip); 1644ilg.Ldloc(oLoc); 1645ilg.Stloc(ilg.ReturnLocal); 1646ilg.Br(ilg.ReturnLabel); 1647ilg.EndIf(); 1654ilg.Ldarg(0); 1655ilg.Call(XmlSerializationReader_get_Reader); 1656ilg.Call(XmlReader_ReadStartElement); 1659ilg.Ldc(0); 1660ilg.Stloc(typeof(int), "state"); 1670ilg.Ldarg(0); 1671ilg.Call(XmlSerializationReader_get_Reader); 1672ilg.Call(XmlReader_MoveToContent); 1673ilg.Pop(); 1683ilg.Ldarg(0); 1684ilg.Call(XmlSerializationReader_ReadEndElement); 1685ilg.Ldloc(structMapping.TypeDesc.Type!, "o"); 1686ilg.Stloc(ilg.ReturnLocal); 1688ilg.MarkLabel(ilg.ReturnLabel); 1689ilg.Ldloc(ilg.ReturnLocal); 1690ilg.EndMethod(); 1709Label labelEnd = ilg.DefineLabel(); 1710Label labelFalse = ilg.DefineLabel(); 1711LocalBuilder sLoc = ilg.GetLocal(source); 1712ilg.Ldloc(sLoc); 1713ilg.Call(XmlQualifiedName_get_Name); 1714ilg.Ldarg(0); 1715ilg.LoadMember(_idNameFields[name ?? string.Empty]); 1716ilg.Bne(labelFalse); 1717ilg.Ldloc(sLoc); 1718ilg.Call(XmlQualifiedName_get_Namespace); 1719ilg.Ldarg(0); 1720ilg.LoadMember(_idNameFields[ns ?? string.Empty]); 1721ilg.Ceq(); 1722ilg.Br_S(labelEnd); 1723ilg.MarkLabel(labelFalse); 1724ilg.Ldc(false); 1725ilg.MarkLabel(labelEnd); 1758Label labelFalse = ilg.DefineLabel(); 1759Label labelEnd = ilg.DefineLabel(); 1763ilg.Ldarg(0); 1764ilg.Call(XmlSerializationReader_get_Reader); 1765ilg.Call(XmlReader_get_LocalName); 1766ilg.Ldarg(0); 1767ilg.LoadMember(_idNameFields[name ?? string.Empty]); 1768ilg.Bne(labelFalse); 1771ilg.Ldarg(0); 1772ilg.Call(XmlSerializationReader_get_Reader); 1773ilg.Call(XmlReader_get_NamespaceURI); 1774ilg.Ldarg(0); 1775ilg.LoadMember(_idNameFields[ns ?? string.Empty]); 1776ilg.Ceq(); 1780ilg.Br_S(labelEnd); 1781ilg.MarkLabel(labelFalse); 1782ilg.Ldc(false); 1783ilg.MarkLabel(labelEnd); 1786ilg.AndIf(); 1817ilg.WhileBegin(); 1838ilg.InitElseIf(); 1840ilg.InitIf(); 1845ilg.Ldc(false); 1846ilg.AndIf(Cmp.EqualTo); 1860ilg.InitElseIf(); 1862ilg.InitIf(); 1886ilg.Ldarg(0); 1887ilg.Ldarg(0); 1888ilg.Call(XmlSerializationReader_get_Reader); 1889ilg.Call(XmlReader_get_Name); 1890ilg.Call(XmlSerializationReader_IsXmlnsAttribute); 1891ilg.Ldc(true); 1892ilg.AndIf(Cmp.EqualTo); 1895ilg.Load(null); 1896ilg.If(Cmp.EqualTo); 1902ilg.New(ctor); 1904ilg.EndIf(); // if (xmlnsMember.Source == null 1906Label labelEqual5 = ilg.DefineLabel(); 1907Label labelEndLength = ilg.DefineLabel(); 1919ilg.Ldarg(0); 1920ilg.Call(XmlSerializationReader_get_Reader); 1921ilg.Call(XmlReader_get_Name); 1922ilg.Call(String_get_Length); 1923ilg.Ldc(5); 1924ilg.Beq(labelEqual5); 1925ilg.Ldarg(0); 1926ilg.Call(XmlSerializationReader_get_Reader); 1927ilg.Call(XmlReader_get_LocalName); 1928ilg.Br(labelEndLength); 1929ilg.MarkLabel(labelEqual5); 1930ilg.Ldstr(string.Empty); 1931ilg.MarkLabel(labelEndLength); 1932ilg.Ldarg(0); 1933ilg.Call(XmlSerializationReader_get_Reader); 1934ilg.Call(XmlReader_get_Value); 1935ilg.Call(Add); 1937ilg.Else(); 1951ilg.Ldarg(0); 1952ilg.Ldarg(0); 1953ilg.Call(XmlSerializationReader_get_Reader); 1954ilg.Call(XmlReader_get_Name); 1955ilg.Call(XmlSerializationReader_IsXmlnsAttribute); 1956ilg.Ldc(false); 1957ilg.AndIf(Cmp.EqualTo); 1961LocalBuilder localAttr = ilg.DeclareOrGetLocal(typeof(XmlAttribute), "attr"); 1972ilg.Ldarg(0); 1973ilg.Call(XmlSerializationReader_get_Document); 1974ilg.Ldarg(0); 1975ilg.Call(XmlSerializationReader_get_Reader); 1976ilg.Call(XmlDocument_ReadNode); 1977ilg.ConvertValue(XmlDocument_ReadNode.ReturnType, localAttr.LocalType); 1978ilg.Stloc(localAttr); 1984ilg.Ldarg(0); 1985ilg.Ldloc(localAttr); 1986ilg.Call(XmlSerializationReader_ParseWsdlArrayType); 1992ilg.Ldarg(0); 1994ilg.Ldloc(firstParam); 1995ilg.ConvertValue(firstParam.LocalType, typeof(object)); 2008ilg.Ldstr(qnames); 2016ilg.Call(elseCallMethod); 2018ilg.EndIf(); 2020ilg.WhileBeginCondition(); 2022ilg.Ldarg(0); 2023ilg.Call(XmlSerializationReader_get_Reader); 2024ilg.Call(XmlReader_MoveToNextAttribute); 2026ilg.WhileEndCondition(); 2027ilg.WhileEnd(); 2039ilg.Ldloc("attr"); 2044LocalBuilder attrLoc = ilg.GetLocal("attr"); 2045ilg.Ldloc(attrLoc); 2049ilg.Load(null); 2050ilg.Cne(); 2053ilg.IsInst(typeof(XmlAttribute)); 2054ilg.If(); 2056ilg.Ldloc(attrLoc); 2057ilg.ConvertValue(attrLoc.LocalType, typeof(XmlAttribute)); 2059ilg.EndIf(); 2068LocalBuilder locListValues = ilg.DeclareOrGetLocal(typeof(string), "listValues"); 2069LocalBuilder locVals = ilg.DeclareOrGetLocal(typeof(string[]), "vals"); 2085ilg.Ldarg(0); 2086ilg.Call(XmlSerializationReader_get_Reader); 2087ilg.Call(XmlReader_get_Value); 2088ilg.Stloc(locListValues); 2089ilg.Ldloc(locListValues); 2090ilg.Load(null); 2091ilg.Call(String_Split); 2092ilg.Stloc(locVals); 2093LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(int), "i"); 2094ilg.For(localI, 0, locVals); 2101ilg.EndFor(); 2137ilg.Ldc(0); 2138ilg.Stloc(typeof(int), c); 2145ilg.Ldc(0); 2146ilg.Stloc(typeof(int), $"c{member.ChoiceArrayName}"); 2155ilg.Ldloc(ilg.GetLocal(a)); 2164ilg.Load(null); 2165ilg.If(Cmp.EqualTo); 2173ilg.Ldarg(0); 2174ilg.Ldstr(GetCSharpString(member.Mapping.TypeDesc.CSharpName)); 2175ilg.Call(XmlSerializationReader_CreateReadOnlyCollectionException); 2176ilg.Throw(); 2181ReflectionAwareILGen.ILGenForCreateInstance(ilg, member.Mapping.TypeDesc.Type!, typeDesc.CannotNew, true); 2184ilg.EndIf(); // if ((object)(member.Source) == null 2186WriteLocalDecl(a, new SourceInfo(member.Source, member.Source, member.Mapping.MemberInfo, member.Mapping.TypeDesc.Type, ilg)); 2230ilg.Load(null); 2231ilg.Stloc(typeof(string), "tmp"); 2245ilg.Ldarg(0); 2246ilg.Call(XmlSerializationReader_get_Reader); 2247ilg.Call(XmlReader_get_NodeType); 2248ilg.Ldc(XmlNodeType_Element); 2249ilg.If(Cmp.EqualTo); 2256ilg.Else(); 2258ilg.EndIf(); 2263ilg.InitElseIf(); 2264Label labelTrue = ilg.DefineLabel(); 2265Label labelEnd = ilg.DefineLabel(); 2276ilg.Ldarg(0); 2277ilg.Call(XmlSerializationReader_get_Reader); 2278ilg.Call(XmlReader_get_NodeType); 2279ilg.Ldc(XmlNodeType.Text); 2280ilg.Ceq(); 2281ilg.Brtrue(labelTrue); 2282ilg.Ldarg(0); 2283ilg.Call(XmlSerializationReader_get_Reader); 2284ilg.Call(XmlReader_get_NodeType); 2285ilg.Ldc(XmlNodeType.CDATA); 2286ilg.Ceq(); 2287ilg.Brtrue(labelTrue); 2288ilg.Ldarg(0); 2289ilg.Call(XmlSerializationReader_get_Reader); 2290ilg.Call(XmlReader_get_NodeType); 2291ilg.Ldc(XmlNodeType.Whitespace); 2292ilg.Ceq(); 2293ilg.Brtrue(labelTrue); 2294ilg.Ldarg(0); 2295ilg.Call(XmlSerializationReader_get_Reader); 2296ilg.Call(XmlReader_get_NodeType); 2297ilg.Ldc(XmlNodeType.SignificantWhitespace); 2298ilg.Ceq(); 2299ilg.Br(labelEnd); 2300ilg.MarkLabel(labelTrue); 2301ilg.Ldc(true); 2302ilg.MarkLabel(labelEnd); 2303ilg.AndIf(); 2342ilg.Ldarg(0); 2343ilg.Call(XmlSerializationReader_get_Document); 2344ilg.Ldarg(0); 2345ilg.Call(XmlSerializationReader_get_Reader); 2346ilg.Call(XmlReader_ReadString); 2347ilg.Call(XmlDocument_CreateTextNode); 2361ilg.Ldarg(0); // for calling CollapseWhitespace 2376ilg.Ldarg(0); 2377ilg.Call(XmlSerializationReader_get_Reader); 2378ilg.Call(XmlReader_ReadString); 2386ilg.Call(XmlSerializationReader_CollapseWhitespace); 2393LocalBuilder tmpLoc = ilg.GetLocal("tmp"); 2399ilg.Ldarg(0); 2400ilg.Ldloc(tmpLoc); 2401ilg.Ldc(text.Mapping.TypeDesc!.CollapseWhitespace); 2402ilg.Call(XmlSerializationReader_ReadString); 2403ilg.Stloc(tmpLoc); 2406ilg.Ldloc(tmpLoc); 2477ilg.InitElseIf(); 2482ilg.InitElseIf(); 2484ilg.InitIf(); 2485ilg.Ldloc("state"); 2486ilg.Ldc(cases); 2487ilg.AndIf(Cmp.EqualTo); 2488ilg.InitIf(); 2492ilg.InitIf(); 2499ilg.Ldc(false); 2500ilg.AndIf(Cmp.EqualTo); 2502Label labelTrue = ilg.DefineLabel(); 2503Label labelEnd = ilg.DefineLabel(); 2511ilg.Ldarg(0); 2512ilg.Call(XmlSerializationReader_get_IsReturnValue); 2513ilg.Brtrue(labelTrue); 2517ilg.Ldc(true); 2525ilg.Br_S(labelEnd); 2526ilg.MarkLabel(labelTrue); 2527ilg.Ldc(true); 2528ilg.MarkLabel(labelEnd); 2530ilg.AndIf(); 2540ilg.Ldarg(0); 2541ilg.Ldc(false); 2542ilg.Call(XmlSerializationReader_set_IsReturnValue); 2553ilg.Else(); 2557ilg.EndIf(); 2560ilg.Ldc(cases); 2561ilg.Stloc(ilg.GetLocal("state")); 2564ilg.EndIf(); 2570ilg.Else(); 2575ilg.EndIf(); 2640ilg.Ldarg(0); 2641ilg.Ldloc(ilg.GetLocal(a)); 2642ilg.Ldloc(ilg.GetLocal(c)); 2643ilg.Ldc(typeDesc.ArrayElementTypeDesc!.Type!); 2644ilg.Ldc(member.IsNullable); 2645ilg.Call(XmlSerializationReader_ShrinkArray); 2646ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, typeDesc.Type!); 2655ilg.Ldarg(0); 2656ilg.Ldloc(ilg.GetLocal(a)); 2657ilg.Ldloc(ilg.GetLocal(c)); 2658ilg.Ldc(member.Mapping.ChoiceIdentifier.Mapping!.TypeDesc!.Type!); 2659ilg.Ldc(member.IsNullable); 2660ilg.Call(XmlSerializationReader_ShrinkArray); 2661ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, member.Mapping.ChoiceIdentifier.Mapping.TypeDesc.Type!.MakeArrayType()); 2667LocalBuilder arrayLoc = ilg.GetLocal(member.ArrayName); 2669ilg.Ldloc(arrayLoc); 2690if (ilg.TryGetVariable(source, out variable)) 2696ilg.LoadAddress(variable); 2703ilg.LdlocAddress(ilg.GetLocal("o")); 2714LocalBuilder localA = ilg.GetLocal(match.Groups["locA1"].Value); 2715LocalBuilder localI = ilg.GetLocal(match.Groups["locI1"].Value); 2722ilg.Ldarg(0); 2723ilg.Ldloc(localA); 2724ilg.Ldloc(localI); 2725ilg.Ldc(arrayElementType); 2726ilg.Call(XmlSerializationReader_EnsureArrayIndex); 2727ilg.Castclass(localA.LocalType); 2728ilg.Stloc(localA); 2731ilg.Ldloc(localA); 2732ilg.Ldloc(localI); 2733ilg.Dup(); 2734ilg.Ldc(1); 2735ilg.Add(); 2736ilg.Stloc(localI); 2739ilg.Ldelema(arrayElementType); 2747LocalBuilder localA = ilg.GetLocal(source.Substring(0, index)); 2748ilg.LdlocAddress(localA); 2756System.Diagnostics.Debug.Assert(CodeGenerator.GetVariableType(ilg.GetVariable(match.Groups["a"].Value)).IsArray); 2757ilg.Load(ilg.GetVariable(match.Groups["a"].Value)); 2758ilg.Load(ilg.GetVariable(match.Groups["ia"].Value)); 2771if (ilg.TryGetVariable(source, out variable)) 2776ilg.Call(varType.GetConstructor(varType.GetGenericArguments())!); 2781ilg.ConvertValue(stackType, elementType); 2782ilg.ConvertValue(elementType, varType); 2783ilg.Stloc((LocalBuilder)variable); 2792ilg.ConvertValue(stackType, memInfo is FieldInfo ? ((FieldInfo)memInfo).FieldType : ((PropertyInfo)memInfo).PropertyType); 2793ilg.StoreMember(memInfo); 2800object oVar = ilg.GetVariable(match.Groups["locA1"].Value); 2802ilg.ConvertValue(elementType, arrayElementType); 2805ilg.Stobj(arrayElementType); 2809ilg.Stelem(arrayElementType); 2817LocalBuilder localA = ilg.GetLocal(source.Substring(0, index)); 2826ilg.ConvertValue(stackType, addParameterType); 2827ilg.Call(Add); 2829ilg.Pop(); 2836Type varType = CodeGenerator.GetVariableType(ilg.GetVariable(match.Groups["a"].Value)); 2839ilg.ConvertValue(stackType, varElementType); 2840ilg.Stelem(varElementType); 2853ilg.Ldarg(0); 2854ilg.Call(XmlSerializationReader_ReadNull); 2855ilg.IfNot(); // if (!ReadNull()) { // EnterScope 2856ilg.EnterScope(); 2872Label labelTrue = ilg.DefineLabel(); 2873Label labelEnd = ilg.DefineLabel(); 2877ilg.Load(ilg.GetVariable(member.ArrayName)); 2878ilg.Load(null); 2879ilg.Beq(labelTrue); 2894ilg.Ldarg(0); 2895ilg.Call(XmlSerializationReader_get_Reader); 2896ilg.Call(XmlReader_get_IsEmptyElement); 2899ilg.Br_S(labelEnd); 2900ilg.MarkLabel(labelTrue); 2901ilg.Ldc(true); 2902ilg.MarkLabel(labelEnd); 2904ilg.If(); 2910ilg.Ldarg(0); 2911ilg.Call(XmlSerializationReader_get_Reader); 2912ilg.Call(XmlReader_Skip); 2913ilg.Else(); 2920ilg.Ldarg(0); 2921ilg.Call(XmlSerializationReader_get_Reader); 2922ilg.Call(XmlReader_ReadStartElement); 2932ilg.Ldarg(0); 2933ilg.Call(XmlSerializationReader_get_Reader); 2934ilg.Call(XmlReader_MoveToContent); 2935ilg.Pop(); 2943ilg.Ldarg(0); 2944ilg.Call(XmlSerializationReader_ReadEndElement); 2945ilg.EndIf(); 2951ilg.ExitScope(); // if (!ReadNull()) { ExitScope 2952ilg.Else(); // } else { EnterScope 2953ilg.EnterScope(); 2958ilg.ExitScope(); // if (!ReadNull())/else ExitScope 2959ilg.EndIf(); 2981ilg.Ldarg(0); 2982ilg.Ldc(true); 2990ilg.Call(methodBuilder); 3003ilg.Ldarg(0); 3004ilg.Call(XmlSerializationReader_ReadNull); 3005ilg.If(); 3013ilg.Load(null); 3016ilg.Else(); 3031ilg.Ldarg(0); 3032ilg.Call(XmlSerializationReader_get_Reader); 3033ilg.Call(XmlReader_get_IsEmptyElement); 3034ilg.If(); 3040ilg.Ldarg(0); 3041ilg.Call(XmlSerializationReader_get_Reader); 3042ilg.Call(XmlReader_Skip); 3043ilg.Else(); 3062ilg.Ldarg(0); 3063ilg.Call(XmlSerializationReader_get_Reader); 3064ilg.Call(XmlReader_get_IsEmptyElement); 3065ilg.If(); 3072ilg.Ldarg(0); 3073ilg.Call(XmlSerializationReader_get_Reader); 3074ilg.Call(XmlReader_Skip); 3075LocalBuilder tmpLoc = ilg.GetTempLocal(element.Mapping.TypeDesc!.Type); 3076ilg.Ldloca(tmpLoc); 3077ilg.InitObj(element.Mapping.TypeDesc!.Type); 3078ilg.Ldloc(tmpLoc); 3080ilg.Else(); 3084ilg.EndIf(); 3096ilg.Ldarg(0); 3097ilg.Call(XmlSerializationReader_ReadElementQualifiedName); 3119ilg.EndIf(); 3142ilg.Ldloc(arrayName!); 3143ilg.Load(null); 3144ilg.If(Cmp.EqualTo); 3145ilg.Ldarg(0); 3146ilg.Call(XmlSerializationReader_get_Reader); 3147ilg.Call(XmlReader_Skip); 3148ilg.Else(); 3152ilg.Ldarg(0); 3155ilg.Load(element.IsNullable); 3158ilg.Ldc(true); 3166ilg.Call(methodBuilder); 3170ilg.EndIf(); 3184ilg.Ldarg(0); 3185ilg.Ldc(element.Any ? false : true); 3186ilg.Call(XmlSerializationReader_ReadXmlXXX); 3189ilg.Castclass(special.TypeDesc.Type!); 3202Label labelTrue = ilg.DefineLabel(); 3203Label labelEnd = ilg.DefineLabel(); 3204LocalBuilder tserLoc = ilg.DeclareOrGetLocal(typeof(XmlQualifiedName), "tser"); 3205ilg.Ldarg(0); 3206ilg.Call(XmlSerializationReader_GetXsiType); 3207ilg.Stloc(tserLoc); 3208ilg.Ldloc(tserLoc); 3209ilg.Load(null); 3210ilg.Ceq(); 3211ilg.Brtrue(labelTrue); 3214ilg.Br_S(labelEnd); 3215ilg.MarkLabel(labelTrue); 3216ilg.Ldc(true); 3217ilg.MarkLabel(labelEnd); 3218ilg.If(); 3227ilg.Ldarg(0); 3228ReflectionAwareILGen.ILGenForCreateInstance(ilg, sm.TypeDesc!.Type!, sm.TypeDesc.CannotNew, false); 3230ilg.ConvertValue(typeof(object), typeof(IXmlSerializable)); 3232ilg.Ldc(true); 3233ilg.Call(XmlSerializationReader_ReadSerializable); 3236ilg.ConvertValue(typeof(IXmlSerializable), sm.TypeDesc.Type!); 3261ReflectionAwareILGen.ILGenForEnumMember(ilg, choice.Mapping!.TypeDesc!.Type!, choice.MemberIds[elementIndex]); 3272Label labelTrue = ilg.DefineLabel(); 3273Label labelEnd = ilg.DefineLabel(); 3274LocalBuilder tserLoc = ilg.GetLocal("tser"); 3275ilg.InitElseIf(); 3276ilg.Ldloc(tserLoc); 3277ilg.Load(null); 3278ilg.Ceq(); 3279ilg.Brtrue(labelTrue); 3282ilg.Br_S(labelEnd); 3283ilg.MarkLabel(labelTrue); 3284ilg.Ldc(true); 3285ilg.MarkLabel(labelEnd); 3286ilg.AndIf(); 3298ilg.Ldarg(0); 3299ReflectionAwareILGen.ILGenForCreateInstance(ilg, derived.TypeDesc!.Type!, derived.TypeDesc.CannotNew, false); 3301ilg.ConvertValue(typeof(object), typeof(IXmlSerializable)); 3303ilg.Ldc(true); 3304ilg.Call(XmlSerializationReader_ReadSerializable); 3307ilg.ConvertValue(typeof(IXmlSerializable), head.TypeDesc.Type!); 3317ilg.Ldarg(0); 3318ilg.Ldstr(GetCSharpString(derived.XsiType.Name)); 3319ilg.Ldstr(GetCSharpString(derived.XsiType.Namespace)); 3320ilg.Ldstr(GetCSharpString(head.XsiType!.Name)); 3321ilg.Ldstr(GetCSharpString(head.XsiType.Namespace)); 3322ilg.Ldstr(GetCSharpString(derived.Type.FullName)); 3323ilg.Ldstr(GetCSharpString(head.Type.FullName)); 3324ilg.Call(XmlSerializationReader_CreateBadDerivationException); 3325ilg.Throw(); 3335ilg.Ldarg(0); 3336ilg.Ldstr(GetCSharpString(derived.XsiType.Name)); 3337ilg.Ldstr(GetCSharpString(derived.XsiType.Namespace)); 3338ilg.Ldstr(GetCSharpString(head.Type!.FullName)); 3339ilg.Call(XmlSerializationReader_CreateMissingIXmlSerializableType); 3340ilg.Throw(); 3360ilg.Ldarg(0); 3361ilg.Call(XmlSerializationReader_get_Reader); 3362ilg.Call(XmlReader_MoveToContent); 3363ilg.Pop(); 3364ilg.WhileBegin(); 3369ilg.WhileBeginCondition(); 3385Label labelFalse = ilg.DefineLabel(); 3386Label labelEnd = ilg.DefineLabel(); 3387ilg.Ldarg(0); 3388ilg.Call(XmlSerializationReader_get_Reader); 3389ilg.Call(XmlReader_get_NodeType); 3390ilg.Ldc(XmlNodeType_EndElement); 3391ilg.Beq(labelFalse); 3392ilg.Ldarg(0); 3393ilg.Call(XmlSerializationReader_get_Reader); 3394ilg.Call(XmlReader_get_NodeType); 3395ilg.Ldc(XmlNodeType_None); 3396ilg.Cne(); 3397ilg.Br_S(labelEnd); 3398ilg.MarkLabel(labelFalse); 3399ilg.Ldc(false); 3400ilg.MarkLabel(labelEnd); 3402ilg.WhileEndCondition(); 3403ilg.WhileEnd(); 3414LocalBuilder paramsRead = ilg.DeclareLocal(typeof(Span<bool>), "paramsRead"); 3417ilg.StackallocSpan(typeof(bool), length); 3421ilg.NewArray(typeof(bool), length); 3422ilg.New(typeof(Span<bool>).GetConstructor(new[] { typeof(bool[]) })!); 3424ilg.Stloc(paramsRead); 3432LocalBuilder loc = ilg.DeclareLocal( 3438ilg.BeginExceptionBlock(); 3440ReflectionAwareILGen.ILGenForCreateInstance(ilg, mapping.TypeDesc.Type!, mapping.TypeDesc.CannotNew, true); 3441ilg.Stloc(loc); 3444ilg.Leave(); 3451ilg.Ldarg(0); 3452ilg.Ldstr(GetCSharpString(fullTypeName)); 3453ilg.Call(XmlSerializationReader_CreateInaccessibleConstructorException); 3454ilg.Throw(); 3462ilg.Ldarg(0); 3463ilg.Ldstr(GetCSharpString(fullTypeName)); 3464ilg.Call(XmlSerializationReader_CreateCtorHasSecurityException); 3465ilg.Throw(); 3467ilg.EndExceptionBlock(); 3473ilg.BeginCatchBlock(exceptionType); 3474ilg.Pop(); 3479ReflectionAwareILGen.WriteArrayLocalDecl(typeName, variableName, new SourceInfo(initValue, initValue, null, arrayTypeDesc.Type, ilg), arrayTypeDesc); 3484ReflectionAwareILGen.WriteCreateInstance(source, ctorInaccessible, type, ilg); 3523ilg.Ldarg(0); 3524ilg.Load(null); 3525ilg.Ldstr(match.Groups["qnames"].Value); 3526ilg.Call(XmlSerializationReader_UnknownNode2); 3533ilg.Ldarg(0); 3534LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3535ilg.Ldloc(localO); 3536ilg.ConvertValue(localO.LocalType, typeof(object)); 3537ilg.Ldstr(match.Groups["qnames"].Value); 3538ilg.Call(XmlSerializationReader_UnknownNode2); 3545ilg.Ldarg(0); 3546LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3547ilg.Ldloc(localO); 3548ilg.ConvertValue(localO.LocalType, typeof(object)); 3549ilg.Load(null); 3550ilg.Call(XmlSerializationReader_UnknownNode2); 3557ilg.Ldarg(0); 3558LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3559ilg.Ldloc(localO); 3560ilg.ConvertValue(localO.LocalType, typeof(object)); 3561ilg.Call(XmlSerializationReader_UnknownNode1); 3571ilg.Ldloca(ilg.GetLocal("paramsRead")); 3572ilg.Ldc(int.Parse(match.Groups["index"].Value, CultureInfo.InvariantCulture)); 3573ilg.Call(typeof(Span<bool>).GetMethod("get_Item")!); 3574ilg.LdindU1(); 3584ilg.Ldloca(ilg.GetLocal("paramsRead")); 3585ilg.Ldc(int.Parse(match.Groups["index"].Value, CultureInfo.InvariantCulture)); 3586ilg.Call(typeof(Span<bool>).GetMethod("get_Item")!); 3587ilg.Ldc(value); 3588ilg.StindI1(); 3602ilg.Ldarg(0); 3603ilg.Call(XmlSerializationReader_CreateUnknownNodeException); 3604ilg.Throw(); 3618ilg.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(); 1481LocalBuilder eLoc = ilg.DeclareLocal(typeof(IEnumerator), "e"); 1482ilg.LoadAddress(ilg.GetVariable(arrayName)); 1494ilg.ConvertValue(arrayTypeDesc.Type!, typeIEnumerable); 1505ilg.ConvertValue(arrayTypeDesc.Type!, typeIEnumerable); 1513ilg.Call(getEnumeratorMethod); 1514ilg.ConvertValue(getEnumeratorMethod.ReturnType, typeof(IEnumerator)); 1515ilg.Stloc(eLoc); 1517ilg.Ldloc(eLoc); 1518ilg.Load(null); 1519ilg.If(Cmp.NotEqualTo); 1520ilg.WhileBegin(); 1524WriteElements(new SourceInfo(arrayNamePlusI, null, null, arrayElementTypeDesc.Type, ilg), $"{choiceName}i", elements, text, choice, arrayNamePlusA, true, true); 1526ilg.WhileBeginCondition(); // while (e.MoveNext()) 1531ilg.Ldloc(eLoc); 1532ilg.Call(IEnumerator_MoveNext); 1533ilg.WhileEndCondition(); 1534ilg.WhileEnd(); 1536ilg.EndIf(); // if (e != null) 1544LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(int), iPlusArrayName); 1545ilg.For(localI, 0, ilg.GetLocal(arrayName)); 1554WriteElements(new SourceInfo(arrayNamePlusI, null, null, arrayElementTypeDesc.Type, ilg), $"{choiceName}i", elements, text, choice, arrayNamePlusA, true, arrayElementTypeDesc.IsNullable); 1558WriteElements(new SourceInfo(ReflectionAwareILGen.GetStringForArrayMember(arrayName, iPlusArrayName), null, null, arrayElementTypeDesc.Type, ilg), null, elements, text, choice, arrayNamePlusA, true, arrayElementTypeDesc.IsNullable); 1560ilg.EndFor(); 1580ilg.Load(null); 1581ilg.If(Cmp.NotEqualTo); 1611if (wroteFirstIf) ilg.InitElseIf(); 1612else { wroteFirstIf = true; ilg.InitIf(); } 1614ilg.Load(enumValue); 1615ilg.Ceq(); 1618Label labelFalse = ilg.DefineLabel(); 1619Label labelEnd = ilg.DefineLabel(); 1620ilg.Brfalse(labelFalse); 1622ilg.Load(null); 1623ilg.Cne(); 1624ilg.Br_S(labelEnd); 1625ilg.MarkLabel(labelFalse); 1626ilg.Ldc(false); 1627ilg.MarkLabel(labelEnd); 1629ilg.AndIf(); 1639if (wroteFirstIf) ilg.InitElseIf(); 1640else { wroteFirstIf = true; ilg.InitIf(); } 1643ilg.AndIf(); 1656else ilg.EndIf(); 1661if (elements.Length - anyCount > 0) ilg.InitElseIf(); 1662else ilg.InitIf(); 1665ilg.IsInst(typeof(XmlElement)); 1666ilg.Load(null); 1667ilg.Cne(); 1668ilg.AndIf(); 1670LocalBuilder elemLoc = ilg.DeclareLocal(typeof(XmlElement), "elem"); 1672ilg.Stloc(elemLoc); 1678if (c++ > 0) ilg.InitElseIf(); 1679else ilg.InitIf(); 1688labelFalse = ilg.DefineLabel(); 1689labelEnd = ilg.DefineLabel(); 1691ilg.Load(enumValue); 1692ilg.Bne(labelFalse); 1696ilg.Load(null); 1697ilg.Cne(); 1701ilg.Ldc(true); 1703ilg.Br(labelEnd); 1704ilg.MarkLabel(labelFalse); 1705ilg.Ldc(false); 1706ilg.MarkLabel(labelEnd); 1707ilg.AndIf(); 1709labelFalse = ilg.DefineLabel(); 1710labelEnd = ilg.DefineLabel(); 1721ilg.Ldloc(elemLoc); 1722ilg.Call(XmlNode_get_Name); 1723ilg.Ldstr(GetCSharpString(element.Name)); 1729ilg.Call(String_op_Equality); 1730ilg.Brfalse(labelFalse); 1731ilg.Ldloc(elemLoc); 1732ilg.Call(XmlNode_get_NamespaceURI); 1733ilg.Ldstr(GetCSharpString(element.Namespace)); 1734ilg.Call(String_op_Equality); 1735ilg.Br(labelEnd); 1736ilg.MarkLabel(labelFalse); 1737ilg.Ldc(false); 1738ilg.MarkLabel(labelEnd); 1739if (choice != null) ilg.If(); 1740else ilg.AndIf(); 1741WriteElement(new SourceInfo("elem", null, null, elemLoc.LocalType, ilg), element, arrayName, writeAccessors); 1745ilg.Else(); 1752ilg.Ldarg(0); 1753ilg.Ldstr(GetCSharpString(enumFullName)); 1754ilg.Ldstr(GetCSharpString(choice.MemberName)); 1755ilg.Ldloc(elemLoc); 1756ilg.Call(XmlNode_get_Name); 1757ilg.Ldloc(elemLoc); 1758ilg.Call(XmlNode_get_NamespaceURI); 1759ilg.Call(XmlSerializationWriter_CreateChoiceIdentifierValueException); 1760ilg.Throw(); 1761ilg.EndIf(); 1766ilg.Else(); 1770WriteElement(new SourceInfo("elem", null, null, elemLoc.LocalType, ilg), unnamedAny, arrayName, writeAccessors); 1779ilg.Ldarg(0); 1780ilg.Ldloc(elemLoc); 1791ilg.Call(XmlNode_get_Name); 1792ilg.Ldloc(elemLoc); 1793ilg.Call(XmlNode_get_NamespaceURI); 1794ilg.Call(XmlSerializationWriter_CreateUnknownAnyElementException); 1795ilg.Throw(); 1799ilg.EndIf(); 1806ilg.InitElseIf(); 1808ilg.AndIf(); 1822ilg.InitElseIf(); 1824ilg.Load(null); 1825ilg.AndIf(Cmp.NotEqualTo); 1829ilg.Else(); 1836ilg.Ldarg(0); 1838ilg.Call(XmlSerializationWriter_CreateUnknownTypeException); 1839ilg.Throw(); 1841ilg.EndIf(); 1845ilg.EndIf(); 1854ilg.Ldarg(0); 1868ilg.Call(XmlSerializationWriter_WriteValue); 1886ilg.Ldarg(0); 1887ilg.Call(XmlSerializationWriter_get_Writer); 1888ilg.Call(WriteTo); 1910ilg.Call(Nullable_get_HasValue); 1915ilg.Load(null); 1916ilg.Cne(); 1918ilg.If(); 1925ilg.Else(); 1928ilg.EndIf(); 1938ilg.EnterScope(); 1949ilg.Ldloc(ilg.GetLocal(arrayName)); 1950ilg.Load(null); 1951ilg.If(Cmp.NotEqualTo); 1959ilg.EndIf(); 1965ilg.EndIf(); 1968ilg.ExitScope(); 1997ilg.Ldarg(0); 1998ilg.Ldstr(GetCSharpString(name)); 2000ilg.Ldstr(GetCSharpString(ns)); 2006ilg.Ldc(element.IsNullable); 2009ilg.Ldc(false); 2016ilg.Call(methodBuilder); 2027Label ifLabel1 = ilg.DefineLabel(); 2028Label ifLabel2 = ilg.DefineLabel(); 2030ilg.IsInst(typeof(XmlNode)); 2031ilg.Brtrue(ifLabel1); 2033ilg.Load(null); 2034ilg.Ceq(); 2035ilg.Br(ifLabel2); 2036ilg.MarkLabel(ifLabel1); 2037ilg.Ldc(true); 2038ilg.MarkLabel(ifLabel2); 2039ilg.If(); 2043ilg.Else(); 2050ilg.Ldarg(0); 2052ilg.Call(XmlSerializationWriter_CreateInvalidAnyTypeException); 2053ilg.Throw(); 2055ilg.EndIf(); 2071ilg.Ldarg(0); 2073ilg.Ldstr(GetCSharpString(name)); 2074ilg.Ldstr(GetCSharpString(ns)); 2075ilg.Ldc(isNullable); 2076ilg.Ldc(isAny); 2077ilg.Call(XmlSerializationWriter_func); 2085Label labelEnd = ilg.DefineLabel(); 2086Label labelFalse = ilg.DefineLabel(); 2087Label labelTrue = ilg.DefineLabel(); 2091ilg.Brfalse(labelTrue); 2094ilg.Brfalse(labelFalse); 2101ilg.Call(String_get_Length); 2102ilg.Ldc(0); 2103ilg.Cne(); 2104ilg.Br(labelEnd); 2107ilg.MarkLabel(labelTrue); 2108ilg.Ldc(true); 2112ilg.MarkLabel(labelFalse); 2113ilg.Ldc(false); 2115ilg.MarkLabel(labelEnd); 2116ilg.If(); 2123ilg.Load(null); 2124ilg.Cne(); 2129ilg.Ldc(Convert.ChangeType(value, source.Type!, CultureInfo.InvariantCulture)); 2130ilg.Cne(); 2136ilg.Ldc(value is string ? GetCSharpString((string)value) : value); 2143ilg.Call(op_Inequality); 2145ilg.Cne(); 2147ilg.If(); 2153Label labelFalse = ilg.DefineLabel(); 2154Label labelEnd = ilg.DefineLabel(); 2156ilg.Load(null); 2157ilg.Beq(labelFalse); 2160ilg.Ldc(false); 2161ilg.Ceq(); 2162ilg.Br(labelEnd); 2163ilg.MarkLabel(labelFalse); 2164ilg.Ldc(false); 2165ilg.MarkLabel(labelEnd); 2166ilg.If(); 2172ilg.Ldarg(0); 2173ilg.Ldstr(GetCSharpString(typeDesc.FullName)); 2174ilg.Ldstr(GetCSharpString(choice.MemberName)); 2175ilg.Ldstr(GetCSharpString(enumName)); 2176ilg.Call(XmlSerializationWriter_CreateMismatchChoiceException); 2177ilg.Throw(); 2178ilg.EndIf(); 2183LocalBuilder local = ilg.GetLocal(source); 2185ilg.Load(local); 2186ilg.Load(null); 2187ilg.If(Cmp.EqualTo); 2189ilg.Else(); 2199ilg.Ldarg(0); 2201ilg.Call(XmlSerializationWriter_WriteNamespaceDeclarations); 2217ReflectionAwareILGen.WriteLocalDecl(variableName, new SourceInfo(initValue, initValue, null, type, ilg)); 2226ReflectionAwareILGen.WriteTypeCompare(variable, type, ilg); 2231ReflectionAwareILGen.WriteInstanceOf(source, type, ilg); 2235ReflectionAwareILGen.WriteArrayTypeCompare(variable, arrayType, ilg);