133ilg = new CodeGenerator(serializerContractTypeBuilder); 212ilg = new CodeGenerator(serializerContractTypeBuilder); 264ilg = new CodeGenerator(baseSerializerTypeBuilder); 307ilg = new CodeGenerator(typedSerializerTypeBuilder); 341ilg = new CodeGenerator(typedSerializerTypeBuilder); 365ilg = new CodeGenerator(typedSerializerTypeBuilder); 420ilg = new CodeGenerator(serializerContractTypeBuilder); 472ilg = new CodeGenerator(serializerContractTypeBuilder); 495ilg = new CodeGenerator(serializerContractTypeBuilder); 531ilg = new CodeGenerator(serializerContractTypeBuilder);

222ilg = new CodeGenerator(this.typeBuilder); 341ilg = new CodeGenerator(this.typeBuilder); 405ilg = new CodeGenerator(this.typeBuilder); 646ilg = new CodeGenerator(this.typeBuilder); 987ilg = new CodeGenerator(this.typeBuilder); 1060ilg = new CodeGenerator(this.typeBuilder); 1307ilg = new CodeGenerator(this.typeBuilder); 1357ilg = new CodeGenerator(this.typeBuilder);

78ilg = new CodeGenerator(this.typeBuilder); 327ilg = new CodeGenerator(this.typeBuilder); 504ilg = new CodeGenerator(this.typeBuilder); 560ilg = new CodeGenerator(this.typeBuilder); 878ilg = new CodeGenerator(this.typeBuilder);

141ilg.BeginMethod( 147propertyBuilder.SetGetMethod(ilg.MethodBuilder); 149ilg.Ldarg(0); 150ilg.LoadMember(fieldBuilder); 151ilg.Load(null); 153ilg.If(Cmp.EqualTo); 161LocalBuilder _tmpLoc = ilg.DeclareLocal(typeof(Hashtable), "_tmp"); 162ilg.New(Hashtable_ctor); 163ilg.Stloc(_tmpLoc); 169ilg.Ldarg(0); 170ilg.LoadMember(fieldBuilder); 171ilg.Load(null); 172ilg.If(Cmp.EqualTo); 174ilg.Ldarg(0); 175ilg.Ldloc(typeof(Hashtable), "_tmp"); 176ilg.StoreMember(fieldBuilder); 178ilg.EndIf(); 180ilg.EndIf(); 182ilg.Ldarg(0); 183ilg.LoadMember(fieldBuilder); 184ilg.GotoMethodEnd(); 186ilg.EndMethod(); 201ilg.Ldloc(typeof(Hashtable), "_tmp"); 202ilg.Ldstr(xmlMappings[i].Key); 203ilg.Ldstr(methods[i]); 204ilg.Call(Hashtable_set_Item); 213ilg.BeginMethod( 233ilg.Ldarg("type"); 234ilg.Ldc(type); 235ilg.If(Cmp.EqualTo); 237ilg.Ldc(true); 238ilg.GotoMethodEnd(); 240ilg.EndIf(); 242ilg.Ldc(false); 243ilg.GotoMethodEnd(); 244ilg.EndMethod(); 265ilg.BeginMethod(typeof(XmlSerializationReader), 270ilg.New(readerCtor); 271ilg.EndMethod(); 279ilg.BeginMethod(typeof(XmlSerializationWriter), 284ilg.New(writerCtor); 285ilg.EndMethod(); 308ilg.BeginMethod( 317ilg.Ldc(true); 318ilg.Stloc(ilg.ReturnLocal); 319ilg.Br(ilg.ReturnLabel); 329ilg.Ldarg(ilg.GetArg("xmlReader")); 330ilg.Ldstr(mapping.Accessor.Name); 331ilg.Ldstr(mapping.Accessor.Namespace); 332ilg.Call(XmlReader_IsStartElement); 333ilg.Stloc(ilg.ReturnLocal); 334ilg.Br(ilg.ReturnLabel); 336ilg.MarkLabel(ilg.ReturnLabel); 337ilg.Ldloc(ilg.ReturnLocal); 338ilg.EndMethod(); 342ilg.BeginMethod( 355ilg.Ldarg("writer"); 356ilg.Castclass(CreatedTypes[writerClass]); 357ilg.Ldarg("objectToSerialize"); 359ilg.ConvertValue(typeof(object), typeof(object[])); 361ilg.Call(writerType_writeMethod); 362ilg.EndMethod(); 366ilg.BeginMethod( 379ilg.Ldarg("reader"); 380ilg.Castclass(CreatedTypes[readerClass]); 381ilg.Call(readerType_readMethod); 382ilg.EndMethod(); 409ilg.Ldloc(typeof(Hashtable), "_tmp"); 410ilg.Ldstr(key); 411ilg.New(ctor); 412ilg.Call(Hashtable_Add); 421ilg.BeginMethod( 438ilg.Ldarg("type"); 439ilg.Ldc(type); 440ilg.If(Cmp.EqualTo); 448ilg.New(ctor); 449ilg.Stloc(ilg.ReturnLocal); 450ilg.Br(ilg.ReturnLabel); 452ilg.EndIf(); 455ilg.Load(null); 456ilg.Stloc(ilg.ReturnLocal); 457ilg.Br(ilg.ReturnLabel); 458ilg.MarkLabel(ilg.ReturnLabel); 459ilg.Ldloc(ilg.ReturnLocal); 460ilg.EndMethod(); 479ilg.BeginMethod( 485propertyBuilder.SetGetMethod(ilg.MethodBuilder); 492ilg.New(ctor); 493ilg.EndMethod(); 502ilg.BeginMethod( 508propertyBuilder.SetGetMethod(ilg.MethodBuilder); 515ilg.New(ctor); 516ilg.EndMethod(); 532ilg.BeginMethod( 539ilg.Ldarg(0); 540ilg.Load(null); 541ilg.StoreMember(readMethodsField); 542ilg.Ldarg(0); 543ilg.Load(null); 544ilg.StoreMember(writeMethodsField); 545ilg.Ldarg(0); 546ilg.Load(null); 547ilg.StoreMember(typedSerializersField); 548ilg.Ldarg(0); 549ilg.Call(baseCtor); 550ilg.EndMethod(); 569ilg.LoadMember(ilg.GetVariable("o"), memInfo); 572ilg.ConvertValue(memType, type); 576SourceInfo info = new SourceInfo(source, null, null, null, ilg);

223ilg.BeginMethod(typeof(void), "InitIDs", CodeGenerator.EmptyTypeArray, CodeGenerator.EmptyStringArray, 248ilg.Ldarg(0); 249ilg.Ldarg(0); 250ilg.Call(XmlSerializationReader_get_Reader); 251ilg.Call(XmlReader_get_NameTable); 252ilg.Ldstr(id); 253ilg.Call(XmlNameTable_Add); 255ilg.StoreMember(idNameFields[id]); 257ilg.EndMethod(); 295ilg.Ldarg(0); 296ilg.Call(XmlSerializationReader_get_Reader); 297ilg.Ldarg(0); 298ilg.LoadMember(idNameFields[name ?? String.Empty]); 299ilg.Ldarg(0); 300ilg.LoadMember(idNameFields[ns ?? String.Empty]); 301ilg.Call(XmlReader_IsStartElement); 302ilg.If(); 307ilg.Else(); 310ilg.Ldarg(0); 313ilg.Load(null); 315object pVar = ilg.GetVariable("p"); 316ilg.Load(pVar); 317ilg.ConvertValue(ilg.GetVariableType(pVar), typeof(object)); 324ilg.Ldstr(ReflectionAwareILGen.GetCSharpString(expectedElement)); 334ilg.Call(method); 336ilg.EndIf(); 342ilg.BeginMethod(typeof(void), "InitCallbacks", CodeGenerator.EmptyTypeArray, CodeGenerator.EmptyStringArray, 347ilg.EndMethod(); 350ilg.BeginMethod( 363ilg.Ldarg(0); 364ilg.Load(null); 365ilg.Call(XmlSerializationReader_UnknownNode1); 366ilg.Load(null); 367ilg.EndMethod(); 406ilg.BeginMethod( 413ilg.Load(null); 414ilg.Stloc(ilg.ReturnLocal); 429ilg.Ldarg(0); 430ilg.Call(XmlSerializationReader_get_Reader); 431ilg.Call(XmlReader_MoveToContent); 432ilg.Pop(); 434LocalBuilder localP = ilg.DeclareLocal(typeof(object[]), "p"); 435ilg.NewArray(typeof(object), mappings.Length); 436ilg.Stloc(localP); 517ilg.Ldarg(0); 518ilg.Ldc(true); 519ilg.Call(XmlSerializationReader_set_IsReturnValue); 536ilg.Ldarg(0); 537ilg.Call(XmlSerializationReader_get_Reader); 538ilg.Call(XmlReader_MoveToElement); 539ilg.Pop(); 552ilg.Ldarg(0); 553ilg.Call(XmlSerializationReader_get_Reader); 554ilg.Call(XmlReader_get_IsEmptyElement); 555ilg.If(); 564ilg.Ldarg(0); 565ilg.Call(XmlSerializationReader_get_Reader); 566ilg.Call(XmlReader_Skip); 567ilg.Ldarg(0); 568ilg.Call(XmlSerializationReader_get_Reader); 569ilg.Call(XmlReader_MoveToContent); 570ilg.Pop(); 571ilg.WhileContinue(); 573ilg.EndIf(); 581ilg.Ldarg(0); 582ilg.Call(XmlSerializationReader_get_Reader); 583ilg.Call(XmlReader_ReadStartElement); 586ilg.Ldc(0); 587ilg.Stloc(typeof(Int32), "state"); 594ilg.Ldarg(0); 595ilg.Call(XmlSerializationReader_get_Reader); 596ilg.Call(XmlReader_MoveToContent); 597ilg.Pop(); 610ilg.Ldarg(0); 611ilg.Call(XmlSerializationReader_ReadEndElement); 616ilg.Ldarg(0); 617ilg.Call(XmlSerializationReader_get_Reader); 618ilg.Call(XmlReader_MoveToContent); 619ilg.Pop(); 623ilg.Ldloc(ilg.GetLocal("p")); 624ilg.EndMethod(); 633LocalBuilder arrayLoc = ilg.GetLocal(arrayName); 634ilg.Ldloc(arrayLoc); 635ilg.Ldc(i); 636RaCodeGen.ILGenForCreateInstance(ilg, mappings[i].TypeDesc.Type, false, false); 637ilg.ConvertValue(mappings[i].TypeDesc.Type, typeof(object)); 638ilg.Stelem(arrayLoc.LocalType.GetElementType()); 647ilg.BeginMethod( 654LocalBuilder oLoc = ilg.DeclareLocal(typeof(object), "o"); 655ilg.Load(null); 656ilg.Stloc(oLoc); 676ilg.Ldarg(0); 677ilg.Call(XmlSerializationReader_get_Reader); 678ilg.Call(XmlReader_MoveToContent); 679ilg.Pop(); 682ilg.Ldloc(oLoc); 684ilg.Stloc(ilg.ReturnLocal); 685ilg.Ldloc(ilg.ReturnLocal); 686ilg.EndMethod(); 712ilg.Ldarg(0); 728ilg.Ldarg(0); 729ilg.Call(XmlSerializationReader_get_Reader); 730ilg.Call(XmlReader_ReadXXXString); 747ilg.Ldarg(0); 748ilg.Call(XmlSerializationReader_get_Reader); 749ilg.Call(XmlReader_get_Value); 752LocalBuilder locVals = ilg.GetLocal("vals"); 753LocalBuilder locI = ilg.GetLocal("i"); 754ilg.LoadArrayElement(locVals, locI); 757ilg.Ldc(false); 762ilg.Call(methodBuilder); 780ilg.Ldarg(0); 781ilg.Call(XmlSerializationReader_get_Reader); 782ilg.Call(XmlReader_ReadXXXString); 799ilg.Ldarg(0); 800ilg.Call(XmlSerializationReader_get_Reader); 801ilg.Call(XmlReader_get_Value); 804LocalBuilder locVals = ilg.GetLocal("vals"); 805LocalBuilder locI = ilg.GetLocal("i"); 806ilg.LoadArrayElement(locVals, locI); 815ilg.Ldarg(0); 816LocalBuilder locVals = ilg.GetLocal("vals"); 817LocalBuilder locI = ilg.GetLocal("i"); 818ilg.LoadArrayElement(locVals, locI); 827ilg.Call(XmlSerializationReader_CollapseWhitespace); 847ilg.Ldarg(0); 848ilg.Ldarg(0); 849ilg.Call(XmlSerializationReader_get_Reader); 850ilg.Call(XmlReader_method); 859ilg.Call(XmlSerializationReader_CollapseWhitespace); 875ilg.Ldarg(0); 910ilg.Ldarg(0); 911ilg.Call(XmlSerializationReader_get_Reader); 912ilg.Call(XmlReader_ReadXXXString); 929ilg.Ldarg(0); 930ilg.Call(XmlSerializationReader_get_Reader); 931ilg.Call(XmlReader_get_Value); 934LocalBuilder locVals = ilg.GetLocal("vals"); 935LocalBuilder locI = ilg.GetLocal("i"); 936ilg.LoadArrayElement(locVals, locI); 940ilg.Ldc(false); 942ilg.Call(ToXXX); 988ilg.BeginMethod( 995ilg.Ldarg(0); 996ilg.LoadMember(fieldBuilder); 997ilg.Load(null); 998ilg.If(Cmp.EqualTo); 1006LocalBuilder hLoc = ilg.DeclareLocal(typeof(Hashtable), "h"); 1007ilg.New(Hashtable_ctor); 1008ilg.Stloc(hLoc); 1020ilg.Ldloc(hLoc); 1021ilg.Ldstr(constants[i].XmlName); 1022ilg.Ldc(Enum.ToObject(mapping.TypeDesc.Type, constants[i].Value)); 1023ilg.ConvertValue(mapping.TypeDesc.Type, typeof(long)); 1024ilg.ConvertValue(typeof(long), typeof(Object)); 1026ilg.Call(Hashtable_Add); 1029ilg.Ldarg(0); 1030ilg.Ldloc(hLoc); 1031ilg.StoreMember(fieldBuilder); 1033ilg.EndIf(); 1035ilg.Ldarg(0); 1036ilg.LoadMember(fieldBuilder); 1038get_TableName = ilg.EndMethod(); 1061ilg.BeginMethod( 1078ilg.Ldarg("s"); 1079ilg.Ldarg(0); 1081ilg.Call(get_TableName); 1082ilg.Ldstr(fullTypeName); 1083ilg.Call(XmlSerializationReader_ToEnum); 1086ilg.ConvertValue(typeof(long), underlyingType); 1088ilg.Stloc(ilg.ReturnLocal); 1089ilg.Br(ilg.ReturnLabel); 1095Label defaultLabel = ilg.DefineLabel(); 1096Label endSwitchLabel = ilg.DefineLabel(); 1098LocalBuilder localTmp = ilg.GetTempLocal(typeof(string)); 1099ilg.Ldarg("s"); 1100ilg.Stloc(localTmp); 1101ilg.Ldloc(localTmp); 1102ilg.Brfalse(defaultLabel); 1110Label caseLabel = ilg.DefineLabel(); 1111ilg.Ldloc(localTmp); 1112ilg.Ldstr(c.XmlName); 1120ilg.Call(String_op_Equality); 1121ilg.Brtrue(caseLabel); 1127ilg.Br(defaultLabel); 1130ilg.MarkLabel(caseLabels[i]); 1131ilg.Ldc(retValues[i]); 1132ilg.Stloc(ilg.ReturnLocal); 1133ilg.Br(ilg.ReturnLabel); 1143ilg.MarkLabel(defaultLabel); 1144ilg.Ldarg(0); 1145ilg.Ldarg("s"); 1147ilg.Ldc(mapping.TypeDesc.Type); 1148ilg.Call(XmlSerializationReader_CreateUnknownConstantException); 1149ilg.Throw(); 1151ilg.MarkLabel(endSwitchLabel); 1154ilg.MarkLabel(ilg.ReturnLabel); 1155ilg.Ldloc(ilg.ReturnLocal); 1156ilg.EndMethod(); 1162ilg.InitElseIf(); 1164ilg.AndIf(); 1173ilg.Ldarg(0); 1175ilg.Ldarg("isNullable"); 1178ilg.Ldc(false); 1187ilg.Call(methodBuilder); 1188ilg.ConvertValue(methodBuilder.ReturnType, ilg.ReturnLocal.LocalType); 1189ilg.Stloc(ilg.ReturnLocal); 1190ilg.Br(ilg.ReturnLabel); 1201ilg.InitElseIf(); 1203ilg.AndIf(); 1218ilg.Ldarg(0); 1219ilg.Call(XmlSerializationReader_get_Reader); 1220ilg.Call(XmlReader_ReadStartElement); 1226LocalBuilder eLoc = ilg.DeclareOrGetLocal(typeof(object), "e"); 1247ilg.Ldarg(0); 1248ilg.Ldarg(0); 1249ilg.Ldarg(0); 1250ilg.Call(XmlSerializationReader_get_Reader); 1251ilg.Call(XmlReader_ReadString); 1252ilg.Call(XmlSerializationReader_CollapseWhitespace); 1253ilg.Call(methodBuilder); 1254ilg.ConvertValue(methodBuilder.ReturnType, eLoc.LocalType); 1255ilg.Stloc(eLoc); 1263ilg.Ldarg(0); 1264ilg.Call(XmlSerializationReader_ReadEndElement); 1265ilg.Ldloc(eLoc); 1266ilg.Stloc(ilg.ReturnLocal); 1267ilg.Br(ilg.ReturnLabel); 1273ilg.InitElseIf(); 1275ilg.AndIf(); 1276ilg.EnterScope(); 1285LocalBuilder aLoc = ilg.DeclareLocal(mapping.TypeDesc.Type, aVar); 1287RaCodeGen.ILGenForCreateInstance(ilg, td.Type, false, false); 1290ilg.Load(null); 1291ilg.Stloc(aLoc); 1294ilg.Ldloc(aLoc); 1295ilg.Stloc(ilg.ReturnLocal); 1296ilg.Br(ilg.ReturnLabel); 1297ilg.ExitScope(); 1308ilg.BeginMethod( 1315LocalBuilder oLoc = ilg.DeclareLocal(nullableMapping.TypeDesc.Type, "o"); 1317ilg.LoadAddress(oLoc); 1318ilg.InitObj(nullableMapping.TypeDesc.Type); 1325ilg.Ldarg(0); 1326ilg.Call(XmlSerializationReader_ReadNull); 1327ilg.If(); 1329ilg.Ldloc(oLoc); 1330ilg.Stloc(ilg.ReturnLocal); 1331ilg.Br(ilg.ReturnLabel); 1333ilg.EndIf(); 1341ilg.Ldloc(oLoc); 1342ilg.Stloc(ilg.ReturnLocal); 1343ilg.Br(ilg.ReturnLabel); 1345ilg.MarkLabel(ilg.ReturnLabel); 1346ilg.Ldloc(ilg.ReturnLocal); 1347ilg.EndMethod(); 1366ilg.BeginMethod( 1373LocalBuilder locXsiType = ilg.DeclareLocal(typeof(XmlQualifiedName), "xsiType"); 1374LocalBuilder locIsNull = ilg.DeclareLocal(typeof(Boolean), "isNull"); 1389Label labelTrue = ilg.DefineLabel(); 1390Label labelEnd = ilg.DefineLabel(); 1391ilg.Ldarg("checkType"); 1392ilg.Brtrue(labelTrue); 1393ilg.Load(null); 1394ilg.Br_S(labelEnd); 1395ilg.MarkLabel(labelTrue); 1396ilg.Ldarg(0); 1397ilg.Call(XmlSerializationReader_GetXsiType); 1398ilg.MarkLabel(labelEnd); 1399ilg.Stloc(locXsiType); 1400ilg.Ldc(false); 1401ilg.Stloc(locIsNull); 1403ilg.Ldarg("isNullable"); 1404ilg.If(); 1406ilg.Ldarg(0); 1407ilg.Call(XmlSerializationReader_ReadNull); 1408ilg.Stloc(locIsNull); 1410ilg.EndIf(); 1413ilg.Ldarg("checkType"); 1414ilg.If(); // if (checkType) 1416ilg.Ldloc(locIsNull); 1417ilg.If(); 1418ilg.Ldloc(locXsiType); 1419ilg.Load(null); 1420ilg.If(Cmp.NotEqualTo); 1428ilg.Ldarg(0); 1429ilg.Ldloc(locXsiType); 1430ilg.Call(XmlSerializationReader_ReadTypedNull); 1431ilg.Stloc(ilg.ReturnLocal); 1432ilg.Br(ilg.ReturnLabel); 1433ilg.Else(); 1438ilg.Load(null); 1439ilg.Stloc(ilg.ReturnLocal); 1440ilg.Br(ilg.ReturnLabel); 1442ilg.EndIf(); // if (xsiType != null) 1444ilg.EndIf(); // if (isNull) 1446ilg.Ldloc(typeof(XmlQualifiedName), "xsiType"); 1447ilg.Load(null); 1448ilg.Ceq(); 1450labelTrue = ilg.DefineLabel(); 1451labelEnd = ilg.DefineLabel(); 1453ilg.Brtrue(labelTrue); 1456ilg.Br_S(labelEnd); 1457ilg.MarkLabel(labelTrue); 1458ilg.Ldc(true); 1459ilg.MarkLabel(labelEnd); 1461ilg.If(); // if (xsiType == null 1476ilg.Ldarg(0); 1477ilg.Ldstr(Soap.UrType); 1478ilg.Ldstr(XmlSchema.Namespace); 1479ilg.New(XmlQualifiedName_ctor); 1480ilg.Call(XmlSerializationReader_ReadTypedPrimitive); 1481ilg.Stloc(ilg.ReturnLocal); 1482ilg.Br(ilg.ReturnLabel); 1486ilg.Else(); // if (xsiType == null 1495ilg.Ldarg(0); 1496ilg.Ldloc(locXsiType); 1497ilg.Call(XmlSerializationReader_ReadTypedPrimitive); 1498ilg.Stloc(ilg.ReturnLocal); 1499ilg.Br(ilg.ReturnLabel); 1509ilg.Ldarg(0); 1510ilg.Ldloc(locXsiType); 1511ilg.Call(XmlSerializationReader_CreateUnknownTypeException); 1512ilg.Throw(); 1514ilg.EndIf(); // if (xsiType == null 1515ilg.EndIf(); // checkType 1518ilg.Ldloc(typeof(bool), "isNull"); 1519ilg.If(); 1521ilg.Load(null); 1522ilg.Stloc(ilg.ReturnLocal); 1523ilg.Br(ilg.ReturnLabel); 1525ilg.EndIf(); 1536ilg.Ldarg(0); 1537ilg.Ldstr(structMapping.TypeName); 1538ilg.Ldstr(structMapping.Namespace); 1539ilg.Call(XmlSerializationReader_CreateAbstractTypeException); 1540ilg.Throw(); 1551ilg.Ldarg(0); 1552ilg.Ldc(false); 1553ilg.Call(XmlSerializationReader_set_DecodeName); 1556LocalBuilder oLoc = ilg.GetLocal("o"); 1648ilg.Ldarg(0); 1649ilg.Call(XmlSerializationReader_get_Reader); 1650ilg.Call(XmlReader_MoveToElement); 1651ilg.Pop(); 1660ilg.Ldarg(0); 1661ilg.Call(XmlSerializationReader_get_Reader); 1662ilg.Call(XmlReader_get_IsEmptyElement); 1663ilg.If(); 1671ilg.Ldarg(0); 1672ilg.Call(XmlSerializationReader_get_Reader); 1673ilg.Call(XmlReader_Skip); 1675ilg.Ldloc(oLoc); 1676ilg.Stloc(ilg.ReturnLocal); 1677ilg.Br(ilg.ReturnLabel); 1678ilg.EndIf(); 1687ilg.Ldarg(0); 1688ilg.Call(XmlSerializationReader_get_Reader); 1689ilg.Call(XmlReader_ReadStartElement); 1691ilg.Ldc(0); 1692ilg.Stloc(typeof(Int32), "state"); 1704ilg.Ldarg(0); 1705ilg.Call(XmlSerializationReader_get_Reader); 1706ilg.Call(XmlReader_MoveToContent); 1707ilg.Pop(); 1719ilg.Ldarg(0); 1720ilg.Call(XmlSerializationReader_ReadEndElement); 1721ilg.Ldloc(structMapping.TypeDesc.Type, "o"); 1722ilg.Stloc(ilg.ReturnLocal); 1724ilg.MarkLabel(ilg.ReturnLabel); 1725ilg.Ldloc(ilg.ReturnLocal); 1726ilg.EndMethod(); 1748Label labelEnd = ilg.DefineLabel(); 1749Label labelFalse = ilg.DefineLabel(); 1750LocalBuilder sLoc = ilg.GetLocal(source); 1751ilg.Ldloc(sLoc); 1752ilg.Call(XmlQualifiedName_get_Name); 1753ilg.Ldarg(0); 1754ilg.LoadMember(idNameFields[name ?? String.Empty]); 1755ilg.Bne(labelFalse); 1756ilg.Ldloc(sLoc); 1757ilg.Call(XmlQualifiedName_get_Namespace); 1758ilg.Ldarg(0); 1759ilg.LoadMember(idNameFields[ns ?? String.Empty]); 1760ilg.Ceq(); 1761ilg.Br_S(labelEnd); 1762ilg.MarkLabel(labelFalse); 1763ilg.Ldc(false); 1764ilg.MarkLabel(labelEnd); 1800Label labelFalse = ilg.DefineLabel(); 1801Label labelEnd = ilg.DefineLabel(); 1804ilg.Ldarg(0); 1805ilg.Call(XmlSerializationReader_get_Reader); 1806ilg.Call(XmlReader_get_LocalName); 1807ilg.Ldarg(0); 1808ilg.LoadMember(idNameFields[name ?? String.Empty]); 1809ilg.Bne(labelFalse); 1812ilg.Ldarg(0); 1813ilg.Call(XmlSerializationReader_get_Reader); 1814ilg.Call(XmlReader_get_NamespaceURI); 1815ilg.Ldarg(0); 1816ilg.LoadMember(idNameFields[ns ?? String.Empty]); 1817ilg.Ceq(); 1820ilg.Br_S(labelEnd); 1821ilg.MarkLabel(labelFalse); 1822ilg.Ldc(false); 1823ilg.MarkLabel(labelEnd); 1826ilg.AndIf(); 1863ilg.WhileBegin(); 1881ilg.InitElseIf(); 1883ilg.InitIf(); 1887ilg.Ldc(false); 1888ilg.AndIf(Cmp.EqualTo); 1901ilg.InitElseIf(); 1903ilg.InitIf(); 1934ilg.Ldarg(0); 1935ilg.Ldarg(0); 1936ilg.Call(XmlSerializationReader_get_Reader); 1937ilg.Call(XmlReader_get_Name); 1938ilg.Call(XmlSerializationReader_IsXmlnsAttribute); 1939ilg.Ldc(true); 1940ilg.AndIf(Cmp.EqualTo); 1943ilg.Load(null); 1944ilg.If(Cmp.EqualTo); 1952ilg.New(ctor); 1954ilg.EndIf(); // if (xmlnsMember.Source == null 1956Label labelEqual5 = ilg.DefineLabel(); 1957Label labelEndLength = ilg.DefineLabel(); 1973ilg.Ldarg(0); 1974ilg.Call(XmlSerializationReader_get_Reader); 1975ilg.Call(XmlReader_get_Name); 1976ilg.Call(String_get_Length); 1977ilg.Ldc(5); 1978ilg.Beq(labelEqual5); 1979ilg.Ldarg(0); 1980ilg.Call(XmlSerializationReader_get_Reader); 1981ilg.Call(XmlReader_get_LocalName); 1982ilg.Br(labelEndLength); 1983ilg.MarkLabel(labelEqual5); 1984ilg.Ldstr(String.Empty); 1985ilg.MarkLabel(labelEndLength); 1986ilg.Ldarg(0); 1987ilg.Call(XmlSerializationReader_get_Reader); 1988ilg.Call(XmlReader_get_Value); 1989ilg.Call(Add); 1991ilg.Else(); 2008ilg.Ldarg(0); 2009ilg.Ldarg(0); 2010ilg.Call(XmlSerializationReader_get_Reader); 2011ilg.Call(XmlReader_get_Name); 2012ilg.Call(XmlSerializationReader_IsXmlnsAttribute); 2013ilg.Ldc(false); 2014ilg.AndIf(Cmp.EqualTo); 2017LocalBuilder localAttr = ilg.DeclareOrGetLocal(typeof(XmlAttribute), "attr"); 2032ilg.Ldarg(0); 2033ilg.Call(XmlSerializationReader_get_Document); 2034ilg.Ldarg(0); 2035ilg.Call(XmlSerializationReader_get_Reader); 2036ilg.Call(XmlDocument_ReadNode); 2037ilg.ConvertValue(XmlDocument_ReadNode.ReturnType, localAttr.LocalType); 2038ilg.Stloc(localAttr); 2046ilg.Ldarg(0); 2047ilg.Ldloc(localAttr); 2048ilg.Call(XmlSerializationReader_ParseWsdlArrayType); 2053ilg.Ldarg(0); 2055ilg.Ldloc(firstParam); 2056ilg.ConvertValue(firstParam.LocalType, typeof(object)); 2067ilg.Ldstr(qnames); 2077ilg.Call(elseCallMethod); 2079ilg.EndIf(); 2081ilg.WhileBeginCondition(); 2083ilg.Ldarg(0); 2084ilg.Call(XmlSerializationReader_get_Reader); 2085ilg.Call(XmlReader_MoveToNextAttribute); 2087ilg.WhileEndCondition(); 2088ilg.WhileEnd(); 2100ilg.Ldloc("attr"); 2104LocalBuilder attrLoc = ilg.GetLocal("attr"); 2105ilg.Ldloc(attrLoc); 2108ilg.Load(null); 2109ilg.Cne(); 2112ilg.IsInst(typeof(XmlAttribute)); 2113ilg.If(); 2115ilg.Ldloc(attrLoc); 2116ilg.ConvertValue(attrLoc.LocalType, typeof(XmlAttribute)); 2118ilg.EndIf(); 2125LocalBuilder locListValues = ilg.DeclareOrGetLocal(typeof(string), "listValues"); 2126LocalBuilder locVals = ilg.DeclareOrGetLocal(typeof(string[]), "vals"); 2148ilg.Ldarg(0); 2149ilg.Call(XmlSerializationReader_get_Reader); 2150ilg.Call(XmlReader_get_Value); 2151ilg.Stloc(locListValues); 2152ilg.Ldloc(locListValues); 2153ilg.Load(null); 2154ilg.Call(String_Split); 2155ilg.Stloc(locVals); 2156LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(Int32), "i"); 2157ilg.For(localI, 0, locVals); 2164ilg.EndFor(); 2194ilg.Ldc(0); 2195ilg.Stloc(typeof(int), c); 2201ilg.Ldc(0); 2202ilg.Stloc(typeof(int), "c" + member.ChoiceArrayName); 2210ilg.Ldloc(ilg.GetLocal(a)); 2217ilg.Load(null); 2218ilg.If(Cmp.EqualTo); 2227ilg.Ldarg(0); 2228ilg.Ldstr(member.Mapping.TypeDesc.CSharpName); 2229ilg.Call(XmlSerializationReader_CreateReadOnlyCollectionException); 2230ilg.Throw(); 2234RaCodeGen.ILGenForCreateInstance(ilg, member.Mapping.TypeDesc.Type, typeDesc.CannotNew, true); 2237ilg.EndIf(); // if ((object)(member.Source) == null 2239WriteLocalDecl(a, new SourceInfo(member.Source, member.Source, member.Mapping.MemberInfo, member.Mapping.TypeDesc.Type, ilg)); 2278ilg.Load(null); 2279ilg.Stloc(typeof(string), "tmp"); 2297ilg.Ldarg(0); 2298ilg.Call(XmlSerializationReader_get_Reader); 2299ilg.Call(XmlReader_get_NodeType); 2300ilg.Ldc(XmlNodeType_Element); 2301ilg.If(Cmp.EqualTo); 2308ilg.Else(); 2310ilg.EndIf(); 2314ilg.InitElseIf(); 2315Label labelTrue = ilg.DefineLabel(); 2316Label labelEnd = ilg.DefineLabel(); 2331ilg.Ldarg(0); 2332ilg.Call(XmlSerializationReader_get_Reader); 2333ilg.Call(XmlReader_get_NodeType); 2334ilg.Ldc(XmlNodeType.Text); 2335ilg.Ceq(); 2336ilg.Brtrue(labelTrue); 2337ilg.Ldarg(0); 2338ilg.Call(XmlSerializationReader_get_Reader); 2339ilg.Call(XmlReader_get_NodeType); 2340ilg.Ldc(XmlNodeType.CDATA); 2341ilg.Ceq(); 2342ilg.Brtrue(labelTrue); 2343ilg.Ldarg(0); 2344ilg.Call(XmlSerializationReader_get_Reader); 2345ilg.Call(XmlReader_get_NodeType); 2346ilg.Ldc(XmlNodeType.Whitespace); 2347ilg.Ceq(); 2348ilg.Brtrue(labelTrue); 2349ilg.Ldarg(0); 2350ilg.Call(XmlSerializationReader_get_Reader); 2351ilg.Call(XmlReader_get_NodeType); 2352ilg.Ldc(XmlNodeType.SignificantWhitespace); 2353ilg.Ceq(); 2354ilg.Br(labelEnd); 2355ilg.MarkLabel(labelTrue); 2356ilg.Ldc(true); 2357ilg.MarkLabel(labelEnd); 2358ilg.AndIf(); 2403ilg.Ldarg(0); 2404ilg.Call(XmlSerializationReader_get_Document); 2405ilg.Ldarg(0); 2406ilg.Call(XmlSerializationReader_get_Reader); 2407ilg.Call(XmlReader_ReadString); 2408ilg.Call(XmlDocument_CreateTextNode); 2419ilg.Ldarg(0); // for calling CollapseWhitespace 2437ilg.Ldarg(0); 2438ilg.Call(XmlSerializationReader_get_Reader); 2439ilg.Call(XmlReader_ReadString); 2448ilg.Call(XmlSerializationReader_CollapseWhitespace); 2453LocalBuilder tmpLoc = ilg.GetLocal("tmp"); 2461ilg.Ldarg(0); 2462ilg.Ldloc(tmpLoc); 2463ilg.Ldc(text.Mapping.TypeDesc.CollapseWhitespace); 2464ilg.Call(XmlSerializationReader_ReadString); 2465ilg.Stloc(tmpLoc); 2468ilg.Ldloc(tmpLoc); 2528ilg.InitElseIf(); 2532ilg.InitElseIf(); 2534ilg.InitIf(); 2535ilg.Ldloc("state"); 2536ilg.Ldc(cases); 2537ilg.AndIf(Cmp.EqualTo); 2538ilg.InitIf(); 2541ilg.InitIf(); 2547ilg.Ldc(false); 2548ilg.AndIf(Cmp.EqualTo); 2550Label labelTrue = ilg.DefineLabel(); 2551Label labelEnd = ilg.DefineLabel(); 2560ilg.Ldarg(0); 2561ilg.Call(XmlSerializationReader_get_IsReturnValue); 2562ilg.Brtrue(labelTrue); 2565ilg.Ldc(true); 2571ilg.Br_S(labelEnd); 2572ilg.MarkLabel(labelTrue); 2573ilg.Ldc(true); 2574ilg.MarkLabel(labelEnd); 2576ilg.AndIf(); 2587ilg.Ldarg(0); 2588ilg.Ldc(false); 2589ilg.Call(XmlSerializationReader_set_IsReturnValue); 2597ilg.Else(); 2600ilg.EndIf(); 2603ilg.Ldc(cases); 2604ilg.Stloc(ilg.GetLocal("state")); 2606ilg.EndIf(); 2611ilg.Else(); 2615ilg.EndIf(); 2677ilg.Ldarg(0); 2678ilg.Ldloc(ilg.GetLocal(a)); 2679ilg.Ldloc(ilg.GetLocal(c)); 2680ilg.Ldc(typeDesc.ArrayElementTypeDesc.Type); 2681ilg.Ldc(member.IsNullable); 2682ilg.Call(XmlSerializationReader_ShrinkArray); 2683ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, typeDesc.Type); 2691ilg.Ldarg(0); 2692ilg.Ldloc(ilg.GetLocal(a)); 2693ilg.Ldloc(ilg.GetLocal(c)); 2694ilg.Ldc(member.Mapping.ChoiceIdentifier.Mapping.TypeDesc.Type); 2695ilg.Ldc(member.IsNullable); 2696ilg.Call(XmlSerializationReader_ShrinkArray); 2697ilg.ConvertValue(XmlSerializationReader_ShrinkArray.ReturnType, member.Mapping.ChoiceIdentifier.Mapping.TypeDesc.Type.MakeArrayType()); 2703LocalBuilder arrayLoc = ilg.GetLocal(member.ArrayName); 2705ilg.Ldloc(arrayLoc); 2718if (ilg.TryGetVariable(source, out variable)) { 2719Type varType = ilg.GetVariableType(variable); 2722ilg.LoadAddress(variable); 2728ilg.LdlocAddress(ilg.GetLocal("o")); 2739LocalBuilder localA = ilg.GetLocal(match.Groups["locA1"].Value); 2740LocalBuilder localI = ilg.GetLocal(match.Groups["locI1"].Value); 2749ilg.Ldarg(0); 2750ilg.Ldloc(localA); 2751ilg.Ldloc(localI); 2752ilg.Ldc(arrayElementType); 2753ilg.Call(XmlSerializationReader_EnsureArrayIndex); 2754ilg.Castclass(localA.LocalType); 2755ilg.Stloc(localA); 2758ilg.Ldloc(localA); 2759ilg.Ldloc(localI); 2760ilg.Dup(); 2761ilg.Ldc(1); 2762ilg.Add(); 2763ilg.Stloc(localI); 2765ilg.Ldelema(arrayElementType); 2772LocalBuilder localA = ilg.GetLocal(source.Substring(0, index)); 2773ilg.LdlocAddress(localA); 2781System.Diagnostics.Debug.Assert(ilg.GetVariableType(ilg.GetVariable(match.Groups["a"].Value)).IsArray); 2782ilg.Load(ilg.GetVariable(match.Groups["a"].Value)); 2783ilg.Load(ilg.GetVariable(match.Groups["ia"].Value)); 2794if (ilg.TryGetVariable(source, out variable)) { 2795Type varType = ilg.GetVariableType(variable); 2797ilg.Call(varType.GetConstructor(varType.GetGenericArguments())); 2801ilg.ConvertValue(stackType, elementType); 2802ilg.ConvertValue(elementType, varType); 2803ilg.Stloc((LocalBuilder)variable); 2811ilg.ConvertValue(stackType, memInfo.MemberType == MemberTypes.Field ? ((FieldInfo)memInfo).FieldType : ((PropertyInfo)memInfo).PropertyType); 2812ilg.StoreMember(memInfo); 2819object oVar = ilg.GetVariable(match.Groups["locA1"].Value); 2820Type arrayElementType = ilg.GetVariableType(oVar).GetElementType(); 2821ilg.ConvertValue(elementType, arrayElementType); 2823ilg.Stobj(arrayElementType); 2826ilg.Stelem(arrayElementType); 2833LocalBuilder localA = ilg.GetLocal(source.Substring(0, index)); 2844ilg.ConvertValue(stackType, addParameterType); 2845ilg.Call(Add); 2847ilg.Pop(); 2854Type varType = ilg.GetVariableType(ilg.GetVariable(match.Groups["a"].Value)); 2857ilg.ConvertValue(stackType, varElementType); 2858ilg.Stelem(varElementType); 2872ilg.Ldarg(0); 2873ilg.Call(XmlSerializationReader_ReadNull); 2874ilg.IfNot(); 2889Label labelTrue = ilg.DefineLabel(); 2890Label labelEnd = ilg.DefineLabel(); 2893ilg.Load(ilg.GetVariable(member.ArrayName)); 2894ilg.Load(null); 2895ilg.Beq(labelTrue); 2913ilg.Ldarg(0); 2914ilg.Call(XmlSerializationReader_get_Reader); 2915ilg.Call(XmlReader_get_IsEmptyElement); 2917ilg.Br_S(labelEnd); 2918ilg.MarkLabel(labelTrue); 2919ilg.Ldc(true); 2920ilg.MarkLabel(labelEnd); 2922ilg.If(); 2930ilg.Ldarg(0); 2931ilg.Call(XmlSerializationReader_get_Reader); 2932ilg.Call(XmlReader_Skip); 2933ilg.Else(); 2942ilg.Ldarg(0); 2943ilg.Call(XmlSerializationReader_get_Reader); 2944ilg.Call(XmlReader_ReadStartElement); 2956ilg.Ldarg(0); 2957ilg.Call(XmlSerializationReader_get_Reader); 2958ilg.Call(XmlReader_MoveToContent); 2959ilg.Pop(); 2969ilg.Ldarg(0); 2970ilg.Call(XmlSerializationReader_ReadEndElement); 2971ilg.EndIf(); 2976ilg.Else(); 2981ilg.EndIf(); 2999ilg.Ldarg(0); 3000ilg.Ldc(true); 3008ilg.Call(methodBuilder); 3021ilg.Ldarg(0); 3022ilg.Call(XmlSerializationReader_ReadNull); 3023ilg.If(); 3029ilg.Load(null); 3032ilg.Else(); 3050ilg.Ldarg(0); 3051ilg.Call(XmlSerializationReader_get_Reader); 3052ilg.Call(XmlReader_get_IsEmptyElement); 3053ilg.If(); 3061ilg.Ldarg(0); 3062ilg.Call(XmlSerializationReader_get_Reader); 3063ilg.Call(XmlReader_Skip); 3064ilg.Else(); 3087ilg.Ldarg(0); 3088ilg.Call(XmlSerializationReader_get_Reader); 3089ilg.Call(XmlReader_get_IsEmptyElement); 3090ilg.If(); 3099ilg.Ldarg(0); 3100ilg.Call(XmlSerializationReader_get_Reader); 3101ilg.Call(XmlReader_Skip); 3108ilg.Ldc(default(TimeSpan).Ticks); 3109ilg.New(TimeSpan_ctor); 3111ilg.Else(); 3115ilg.EndIf(); 3128ilg.Ldarg(0); 3129ilg.Call(XmlSerializationReader_ReadElementQualifiedName); 3148ilg.EndIf(); 3173ilg.Ldloc(arrayName); 3174ilg.Load(null); 3175ilg.If(Cmp.EqualTo); 3176ilg.Ldarg(0); 3177ilg.Call(XmlSerializationReader_get_Reader); 3178ilg.Call(XmlReader_Skip); 3179ilg.Else(); 3183ilg.Ldarg(0); 3185ilg.Load(element.IsNullable); 3188ilg.Ldc(true); 3196ilg.Call(methodBuilder); 3200ilg.EndIf(); 3215ilg.Ldarg(0); 3216ilg.Ldc(element.Any ? false : true); 3217ilg.Call(XmlSerializationReader_ReadXmlXXX); 3220ilg.Castclass(special.TypeDesc.Type); 3234Label labelTrue = ilg.DefineLabel(); 3235Label labelEnd = ilg.DefineLabel(); 3236LocalBuilder tserLoc = ilg.DeclareOrGetLocal(typeof(XmlQualifiedName), "tser"); 3237ilg.Ldarg(0); 3238ilg.Call(XmlSerializationReader_GetXsiType); 3239ilg.Stloc(tserLoc); 3240ilg.Ldloc(tserLoc); 3241ilg.Load(null); 3242ilg.Ceq(); 3243ilg.Brtrue(labelTrue); 3246ilg.Br_S(labelEnd); 3247ilg.MarkLabel(labelTrue); 3248ilg.Ldc(true); 3249ilg.MarkLabel(labelEnd); 3250ilg.If(); 3261ilg.Ldarg(0); 3262RaCodeGen.ILGenForCreateInstance(ilg, sm.TypeDesc.Type, sm.TypeDesc.CannotNew, false); 3264ilg.ConvertValue(typeof(object), typeof(IXmlSerializable)); 3266ilg.Ldc(true); 3267ilg.Call(XmlSerializationReader_ReadSerializable); 3270ilg.ConvertValue(typeof(IXmlSerializable), sm.TypeDesc.Type); 3292RaCodeGen.ILGenForEnumMember(ilg, choice.Mapping.TypeDesc.Type, choice.MemberIds[elementIndex]); 3301Label labelTrue = ilg.DefineLabel(); 3302Label labelEnd = ilg.DefineLabel(); 3303LocalBuilder tserLoc = ilg.GetLocal("tser"); 3304ilg.InitElseIf(); 3305ilg.Ldloc(tserLoc); 3306ilg.Load(null); 3307ilg.Ceq(); 3308ilg.Brtrue(labelTrue); 3311ilg.Br_S(labelEnd); 3312ilg.MarkLabel(labelTrue); 3313ilg.Ldc(true); 3314ilg.MarkLabel(labelEnd); 3315ilg.AndIf(); 3327ilg.Ldarg(0); 3328RaCodeGen.ILGenForCreateInstance(ilg, derived.TypeDesc.Type, derived.TypeDesc.CannotNew, false); 3330ilg.ConvertValue(typeof(object), typeof(IXmlSerializable)); 3332ilg.Ldc(true); 3333ilg.Call(XmlSerializationReader_ReadSerializable); 3336ilg.ConvertValue(typeof(IXmlSerializable), head.TypeDesc.Type); 3347ilg.Ldarg(0); 3348ilg.Ldstr(derived.XsiType.Name); 3349ilg.Ldstr(derived.XsiType.Namespace); 3350ilg.Ldstr(head.XsiType.Name); 3351ilg.Ldstr(head.XsiType.Namespace); 3352ilg.Ldstr(derived.Type.FullName); 3353ilg.Ldstr(head.Type.FullName); 3354ilg.Call(XmlSerializationReader_CreateBadDerivationException); 3355ilg.Throw(); 3366ilg.Ldarg(0); 3367ilg.Ldstr(derived.XsiType.Name); 3368ilg.Ldstr(derived.XsiType.Namespace); 3369ilg.Ldstr(head.Type.FullName); 3370ilg.Call(XmlSerializationReader_CreateMissingIXmlSerializableType); 3371ilg.Throw(); 3394ilg.Ldarg(0); 3395ilg.Call(XmlSerializationReader_get_Reader); 3396ilg.Call(XmlReader_MoveToContent); 3397ilg.Pop(); 3399ilg.WhileBegin(); 3405ilg.WhileBeginCondition(); 3425Label labelFalse = ilg.DefineLabel(); 3426Label labelEnd = ilg.DefineLabel(); 3427ilg.Ldarg(0); 3428ilg.Call(XmlSerializationReader_get_Reader); 3429ilg.Call(XmlReader_get_NodeType); 3430ilg.Ldc(XmlNodeType_EndElement); 3431ilg.Beq(labelFalse); 3432ilg.Ldarg(0); 3433ilg.Call(XmlSerializationReader_get_Reader); 3434ilg.Call(XmlReader_get_NodeType); 3435ilg.Ldc(XmlNodeType_None); 3436ilg.Cne(); 3437ilg.Br_S(labelEnd); 3438ilg.MarkLabel(labelFalse); 3439ilg.Ldc(false); 3440ilg.MarkLabel(labelEnd); 3442ilg.WhileEndCondition(); 3443ilg.WhileEnd(); 3454ilg.Ldc(0); 3455ilg.Stloc(typeof(Int32), String.Format(CultureInfo.InvariantCulture, "whileIterations{0}", nextWhileLoopIndex)); 3456ilg.Ldarg(0); 3457ilg.Call(XmlSerializationReader_get_ReaderCount); 3458ilg.Stloc(typeof(Int32), String.Format(CultureInfo.InvariantCulture, "readerCount{0}", nextWhileLoopIndex)); 3471ilg.Ldarg(0); 3472ilg.Ldloca(ilg.GetLocal(String.Format(CultureInfo.InvariantCulture, "whileIterations{0}", loopIndex))); 3473ilg.Ldloca(ilg.GetLocal(String.Format(CultureInfo.InvariantCulture, "readerCount{0}", loopIndex))); 3474ilg.Call(XmlSerializationReader_CheckReaderCount); 3478LocalBuilder paramsRead = ilg.DeclareLocal(typeof(Boolean[]), "paramsRead"); 3479ilg.NewArray(typeof(Boolean), length); 3480ilg.Stloc(paramsRead); 3487LocalBuilder loc = ilg.DeclareLocal( 3492ilg.BeginExceptionBlock(); 3494RaCodeGen.ILGenForCreateInstance(ilg, mapping.TypeDesc.Type, mapping.TypeDesc.CannotNew, true); 3495ilg.Stloc(loc); 3497ilg.Leave(); 3506ilg.Ldarg(0); 3507ilg.Ldstr(fullTypeName); 3508ilg.Call(XmlSerializationReader_CreateInaccessibleConstructorException); 3509ilg.Throw(); 3519ilg.Ldarg(0); 3520ilg.Ldstr(fullTypeName); 3521ilg.Call(XmlSerializationReader_CreateCtorHasSecurityException); 3522ilg.Throw(); 3524ilg.EndExceptionBlock(); 3529ilg.BeginCatchBlock(exceptionType); 3530ilg.Pop(); 3542ilg.Ldarg(0); 3543ilg.Ldc(typeDesc.Type); 3554object idsLoc = ilg.GetVariable("ids"); 3555ilg.Ldarg(0); 3557ilg.LoadArrayElement(idsLoc, Int32.Parse(source.Substring(14, source.Length - 16), CultureInfo.InvariantCulture)); 3558ilg.Call(XmlSerializationReader_GetTarget); 3561ilg.Load(ilg.GetVariable(source)); 3565ilg.Load(null); 3569object idsLoc = ilg.GetVariable("ids"); 3571ilg.LoadArrayElement(idsLoc, Int32.Parse(id.Substring(4, id.Length - 5), CultureInfo.InvariantCulture)); 3574object idVar = ilg.GetVariable(id); 3575ilg.Load(idVar); 3576ilg.ConvertValue(ilg.GetVariableType(idVar), typeof(string)); 3579ilg.Call(XmlSerializationReader_CreateInvalidCastException); 3580ilg.Throw(); 3583RaCodeGen.WriteArrayLocalDecl(typeName, variableName, new SourceInfo(initValue, initValue, null, arrayTypeDesc.Type, ilg), arrayTypeDesc); 3586RaCodeGen.WriteCreateInstance(source, ctorInaccessible, type, ilg); 3610ilg.Ldarg(0); 3611ilg.Load(null); 3612ilg.Ldstr(match.Groups["qnames"].Value); 3613ilg.Call(XmlSerializationReader_UnknownNode2); 3620ilg.Ldarg(0); 3621LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3622ilg.Ldloc(localO); 3623ilg.ConvertValue(localO.LocalType, typeof(object)); 3624ilg.Ldstr(match.Groups["qnames"].Value); 3625ilg.Call(XmlSerializationReader_UnknownNode2); 3632ilg.Ldarg(0); 3633LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3634ilg.Ldloc(localO); 3635ilg.ConvertValue(localO.LocalType, typeof(object)); 3636ilg.Load(null); 3637ilg.Call(XmlSerializationReader_UnknownNode2); 3644ilg.Ldarg(0); 3645LocalBuilder localO = ilg.GetLocal(match.Groups["o"].Value); 3646ilg.Ldloc(localO); 3647ilg.ConvertValue(localO.LocalType, typeof(object)); 3648ilg.Call(XmlSerializationReader_UnknownNode1); 3657ilg.LoadArrayElement(ilg.GetLocal("paramsRead"), Int32.Parse(match.Groups["index"].Value, CultureInfo.InvariantCulture)); 3666ilg.StoreArrayElement(ilg.GetLocal("paramsRead"), Int32.Parse(match.Groups["index"].Value, CultureInfo.InvariantCulture), value); 3680ilg.Ldarg(0); 3681ilg.Call(XmlSerializationReader_CreateUnknownNodeException); 3682ilg.Throw(); 3693ilg.Load(value);

79ilg.BeginMethod(typeof(void), "InitCallbacks", CodeGenerator.EmptyTypeArray, CodeGenerator.EmptyStringArray, 81ilg.EndMethod(); 90ilg.Ldarg(0); 91ilg.Ldstr(name); 94ilg.Ldstr(ns); 107ilg.Call(XmlSerializationWriter_WriteXXX); 129ilg.Ldarg(0); 131ilg.Call(methodBuilder); 151ilg.Call(XmlConvert_ToString); 159ilg.Ldarg(0); 169ilg.Call(FromXXX); 200ilg.Ldc(Enum.Parse(mapping.TypeDesc.Type, enumDefaultValue, false)); 201ilg.If(Cmp.NotEqualTo); // " != " 208ilg.Ldarg(0); 210ilg.Ldstr(name); 213ilg.Ldstr(ns); 234ilg.Ldstr(mapping.TypeName); 235ilg.Ldstr(mapping.Namespace); 236ilg.New(XmlQualifiedName_ctor); 246ilg.Call(XmlSerializationWriter_method); 249ilg.EndIf(); 261ilg.Ldarg(0); 262ilg.Ldstr(name); 263ilg.Ldstr(ns); 264ilg.Call(XmlSerializationWriter_Method); 275ilg.Ldarg(0); 276ilg.Ldstr(name); 277ilg.Ldstr(ns); 278ilg.Load(null); 279ilg.Ldc(writePrefixed); 280ilg.Call(XmlSerializationWriter_Method); 295ilg.Ldarg(0); 296ilg.Call(XmlSerializationWriter_WriteEndElement); 306object oVar = ilg.GetVariable(source); 307ilg.Ldarg(0); 308ilg.Load(oVar); 309ilg.ConvertValue(ilg.GetVariableType(oVar), typeof(Object)); 310ilg.Call(XmlSerializationWriter_WriteEndElement); 328ilg.BeginMethod( 343ilg.Ldarg(0); 344ilg.Call(XmlSerializationWriter_WriteStartDocument); 353ilg.Ldarg(0); 354ilg.Call(XmlSerializationWriter_TopLevelElement); 359LocalBuilder pLengthLoc = ilg.DeclareLocal(typeof(int), "pLength"); 360ilg.Ldarg("p"); 361ilg.Ldlen(); 362ilg.Stloc(pLengthLoc); 372ilg.Ldloc(pLengthLoc); 373ilg.Ldc(xmlnsMember); 374ilg.If(Cmp.GreaterThan); 376ilg.EndIf(); 383SourceInfo source = new SourceInfo("p[" + i.ToString(CultureInfo.InvariantCulture) + "]", null, null, pLengthLoc.LocalType.GetElementType(), ilg); 391specifiedSource = new SourceInfo("((bool)p[" + j.ToString(CultureInfo.InvariantCulture) + "])", null, null, typeof(bool), ilg); 398ilg.Ldloc(pLengthLoc); 399ilg.Ldc(i); 400ilg.If(Cmp.GreaterThan); 403Label labelTrue = ilg.DefineLabel(); 404Label labelEnd = ilg.DefineLabel(); 405ilg.Ldloc(pLengthLoc); 406ilg.Ldc(specifiedPosition); 407ilg.Ble(labelTrue); 409ilg.Br_S(labelEnd); 410ilg.MarkLabel(labelTrue); 411ilg.Ldc(true); 412ilg.MarkLabel(labelEnd); 413ilg.If(); 419ilg.EndIf(); 422ilg.EndIf(); 441specifiedSource = new SourceInfo("((bool)p[" + j.ToString(CultureInfo.InvariantCulture) + "])", null, null, typeof(bool), ilg); 448ilg.Ldloc(pLengthLoc); 449ilg.Ldc(i); 450ilg.If(Cmp.GreaterThan); 453Label labelTrue = ilg.DefineLabel(); 454Label labelEnd = ilg.DefineLabel(); 455ilg.Ldloc(pLengthLoc); 456ilg.Ldc(specifiedPosition); 457ilg.Ble(labelTrue); 459ilg.Br_S(labelEnd); 460ilg.MarkLabel(labelTrue); 461ilg.Ldc(true); 462ilg.MarkLabel(labelEnd); 463ilg.If(); 484WriteMember(new SourceInfo(source, source, null, null, ilg), enumSource, member.ElementsSortedByDerivation, member.Text, member.ChoiceIdentifier, member.TypeDesc, writeAccessors || hasWrapperElement); 487ilg.EndIf(); 490ilg.EndIf(); 496ilg.EndMethod(); 505ilg.BeginMethod( 520ilg.Ldarg(0); 521ilg.Call(XmlSerializationWriter_WriteStartDocument); 523ilg.If(ilg.GetArg("o"), Cmp.EqualTo, null); 529ilg.GotoMethodEnd(); 530ilg.EndIf(); 540ilg.Ldarg(0); 541ilg.Call(XmlSerializationWriter_TopLevelElement); 544WriteMember(new SourceInfo("o", "o", null, typeof(object), ilg), null, new ElementAccessor[] { element }, null, null, mapping.TypeDesc, true); 546ilg.EndMethod(); 561ilg.BeginMethod( 567LocalBuilder sLoc = ilg.DeclareLocal(typeof(string), "s"); 568ilg.Load(null); 569ilg.Stloc(sLoc); 576Label defaultLabel = ilg.DefineLabel(); 577Label endSwitchLabel = ilg.DefineLabel(); 579LocalBuilder localTmp = ilg.DeclareLocal(mapping.TypeDesc.Type, "localTmp"); 580ilg.Ldarg("v"); 581ilg.Stloc(localTmp); 585Label caseLabel = ilg.DefineLabel(); 586ilg.Ldloc(localTmp); 587ilg.Ldc(Enum.ToObject(mapping.TypeDesc.Type, c.Value)); 588ilg.Beq(caseLabel); 597ilg.Br(defaultLabel); 599ilg.MarkLabel(caseLabels[i]); 600ilg.Ldc(retValues[i]); 601ilg.Stloc(sLoc); 602ilg.Br(endSwitchLabel); 604ilg.MarkLabel(defaultLabel); 605RaCodeGen.ILGenForEnumLongValue(ilg, "v"); 606LocalBuilder strArray = ilg.DeclareLocal(typeof(String[]), "strArray"); 607ilg.NewArray(typeof(String), constants.Length); 608ilg.Stloc(strArray); 611ilg.Ldloc(strArray); 612ilg.Ldc(i); 613ilg.Ldstr(c.XmlName); 614ilg.Stelem(typeof(String)); 616ilg.Ldloc(strArray); 617LocalBuilder longArray = ilg.DeclareLocal(typeof(long[]), "longArray"); 618ilg.NewArray(typeof(long), constants.Length); 619ilg.Stloc(longArray); 623ilg.Ldloc(longArray); 624ilg.Ldc(i); 625ilg.Ldc(c.Value); 626ilg.Stelem(typeof(long)); 628ilg.Ldloc(longArray); 629ilg.Ldstr(mapping.TypeDesc.FullName); 637ilg.Call(XmlSerializationWriter_FromEnum); 638ilg.Stloc(sLoc); 639ilg.Br(endSwitchLabel); 642ilg.Br(defaultLabel); 645ilg.MarkLabel(caseLabels[i]); 646ilg.Ldc(retValues[i]); 647ilg.Stloc(sLoc); 648ilg.Br(endSwitchLabel); 672ilg.MarkLabel(defaultLabel); 673ilg.Ldarg(0); 674ilg.Ldarg("v"); 675ilg.ConvertValue(mapping.TypeDesc.Type, typeof(Int64)); 676LocalBuilder numLoc = ilg.DeclareLocal(typeof(Int64), "num"); 677ilg.Stloc(numLoc); 679ilg.LdlocAddress(numLoc); 680ilg.Call(CultureInfo_get_InvariantCulture); 681ilg.Call(Int64_ToString); 682ilg.Ldstr(mapping.TypeDesc.FullName); 683ilg.Call(XmlSerializationWriter_CreateInvalidEnumValueException); 684ilg.Throw(); 686ilg.MarkLabel(endSwitchLabel); 688ilg.Ldloc(sLoc); 689ilg.EndMethod(); 694ilg.InitElseIf(); 696ilg.AndIf(); 706ilg.Ldarg(0); 708ilg.Ldarg("n"); 710ilg.Ldarg("ns"); 711object oVar = ilg.GetVariable("o"); 712Type oType = ilg.GetVariableType(oVar); 713ilg.Load(oVar); 714ilg.ConvertValue(oType, derived.TypeDesc.Type); 718ilg.Ldarg("isNullable"); 721ilg.Ldc(true); 727ilg.Call(methodBuilder); 728ilg.GotoMethodEnd(); 739ilg.InitElseIf(); 742ilg.AndIf(); 764ilg.Ldarg(0); 765ilg.Call(XmlSerializationWriter_get_Writer); 766ilg.Ldarg("n"); 767ilg.Ldarg("ns"); 768ilg.Call(XmlWriter_WriteStartElement); 776ilg.Ldarg(0); 777ilg.Ldstr(mapping.TypeName); 778ilg.Ldstr(mapping.Namespace); 779ilg.Call(XmlSerializationWriter_WriteXsiType); 793ilg.Ldarg(0); 794ilg.Call(XmlSerializationWriter_get_Writer); 795object oVar = ilg.GetVariable("o"); 796ilg.Ldarg(0); 797ilg.Load(oVar); 798ilg.ConvertValue(ilg.GetVariableType(oVar), mapping.TypeDesc.Type); 799ilg.Call(methodBuilder); 800ilg.Call(XmlWriter_WriteString); 808ilg.Ldarg(0); 809ilg.Call(XmlSerializationWriter_get_Writer); 810ilg.Call(XmlWriter_WriteEndElement); 811ilg.GotoMethodEnd(); 816ilg.InitElseIf(); 822ilg.AndIf(); 823ilg.EnterScope(); 839ilg.Ldarg(0); 840ilg.Call(XmlSerializationWriter_get_Writer); 841ilg.Ldarg("n"); 842ilg.Ldarg("ns"); 843ilg.Call(XmlWriter_WriteStartElement); 851ilg.Ldarg(0); 852ilg.Ldstr(mapping.TypeName); 853ilg.Ldstr(mapping.Namespace); 854ilg.Call(XmlSerializationWriter_WriteXsiType); 856WriteMember(new SourceInfo("o", "o", null, null, ilg), null, mapping.ElementsSortedByDerivation, null, null, mapping.TypeDesc, true); 865ilg.Ldarg(0); 866ilg.Call(XmlSerializationWriter_get_Writer); 867ilg.Call(XmlWriter_WriteEndElement); 868ilg.GotoMethodEnd(); 869ilg.ExitScope(); 893ilg.BeginMethod(typeof(void), 899ilg.If(ilg.GetArg("o"), Cmp.EqualTo, null); 901ilg.If(ilg.GetArg("isNullable"), Cmp.EqualTo, true); 910ilg.Ldarg(0); 911ilg.Ldarg("n"); 912ilg.Ldarg("ns"); 913ilg.Call(XmlSerializationWriter_WriteNullTagLiteral); 915ilg.EndIf(); 916ilg.GotoMethodEnd(); 918ilg.EndIf(); 920ilg.If(ilg.GetArg("needType"), Cmp.NotEqualTo, true); // if (!needType) 922LocalBuilder tLoc = ilg.DeclareLocal(typeof(Type), "t"); 930ArgBuilder oArg = ilg.GetArg("o"); 931ilg.LdargAddress(oArg); 932ilg.ConvertAddress(oArg.ArgType, typeof(object)); 933ilg.Call(Object_GetType); 934ilg.Stloc(tLoc); 937ilg.If(); // if (t == typeof(...)) 941ilg.Else(); 950ilg.Ldarg(0); 951ilg.Ldarg("n"); 952ilg.Ldarg("ns"); 953ilg.Ldarg("o"); 954ilg.Ldc(true); 955ilg.Call(XmlSerializationWriter_WriteTypedPrimitive); 956ilg.GotoMethodEnd(); 966ilg.Ldarg(0); 967ilg.Ldarg(oArg); 968ilg.ConvertValue(oArg.ArgType, typeof(Object)); 969ilg.Call(XmlSerializationWriter_CreateUnknownTypeException); 970ilg.Throw(); 972ilg.EndIf(); // if (t == typeof(...)) 973ilg.EndIf(); // if (!needType) 984ilg.Ldarg(0); 985ilg.Ldc(false); 986ilg.Call(XmlSerializationWriter_set_EscapeName); 998ilg.Ldarg(0); 999ilg.Ldarg("n"); 1000ilg.Ldarg("ns"); 1001ArgBuilder argO = ilg.GetArg("o"); 1002ilg.Ldarg(argO); 1003ilg.ConvertValue(argO.ArgType, typeof(Object)); 1004ilg.Ldc(false); 1006ilg.Load(null); 1019ilg.Call(XmlSerializationWriter_WriteStartElement); 1021ilg.If(ilg.GetArg("needType"), Cmp.EqualTo, true); 1030ilg.Ldarg(0); 1031ilg.Ldstr(mapping.TypeName); 1032ilg.Ldstr(mapping.Namespace); 1033ilg.Call(XmlSerializationWriter_WriteXsiType); 1035ilg.EndIf(); 1042ilg.LdargAddress(oArg); 1043ilg.Call(m.CheckShouldPersistMethodInfo); 1044ilg.If(); 1049ilg.If(); 1051WriteMember(RaCodeGen.GetSourceForMember("o", m, mapping.TypeDesc, ilg), m.Attribute, m.TypeDesc, "o"); 1054ilg.EndIf(); 1057ilg.EndIf(); 1070ilg.LdargAddress(oArg); 1071ilg.Call(m.CheckShouldPersistMethodInfo); 1072ilg.If(); 1077ilg.If(); 1086WriteMember(RaCodeGen.GetSourceForMember("o", m, m.MemberInfo, mapping.TypeDesc, ilg), choiceSource, m.ElementsSortedByDerivation, m.Text, m.ChoiceIdentifier, m.TypeDesc, true); 1090ilg.EndIf(); 1093ilg.EndIf(); 1098ilg.EndMethod(); 1119ilg.Ldloc(memberTypeDesc.Type, aVar); 1120ilg.Load(null); 1121ilg.If(Cmp.NotEqualTo); 1140ilg.Ldarg(0); 1141ilg.Call(XmlSerializationWriter_get_Writer); 1142ilg.Load(null); 1143ilg.Ldstr(attribute.Name); 1144ilg.Ldstr(ns); 1145ilg.Call(XmlWriter_WriteStartAttribute); 1148LocalBuilder sbLoc = ilg.DeclareOrGetLocal(typeof(StringBuilder), "sb"); 1155ilg.New(StringBuilder_ctor); 1156ilg.Stloc(sbLoc); 1166LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(Int32), iVar); 1167ilg.For(localI, 0, ilg.GetLocal(aVar)); 1170LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(Int32), iVar); 1171ilg.For(localI, 0, ilg.GetLocal(aVar)); 1181ilg.Ldloc(iVar); 1182ilg.Ldc(0); 1183ilg.If(Cmp.NotEqualTo); 1198ilg.Ldarg(0); 1199ilg.Call(XmlSerializationWriter_get_Writer); 1200ilg.Ldstr(" "); 1201ilg.Call(XmlWriter_WriteString); 1202ilg.EndIf(); 1203ilg.Ldarg(0); 1215ilg.Ldloc(iVar); 1216ilg.Ldc(0); 1217ilg.If(Cmp.NotEqualTo); 1218ilg.Ldloc("sb"); 1219ilg.Ldstr(" "); 1220ilg.Call(StringBuilder_Append); 1221ilg.Pop(); 1222ilg.EndIf(); 1223ilg.Ldloc("sb"); 1228WriteEnumValue((EnumMapping)attribute.Mapping, new SourceInfo(aiVar, aiVar, null, arrayElementTypeDesc.Type, ilg), out argType); 1230WritePrimitiveValue(arrayElementTypeDesc, new SourceInfo(aiVar, aiVar, null, arrayElementTypeDesc.Type, ilg), out argType); 1238ilg.Call(method); 1240ilg.Pop(); 1243WriteAttribute(new SourceInfo(aiVar, aiVar, null, null, ilg), attribute, parent); 1248ilg.EndFor(); 1266ilg.Ldarg(0); 1267ilg.Call(XmlSerializationWriter_get_Writer); 1268ilg.Call(XmlWriter_WriteEndAttribute); 1278ilg.Ldloc("sb"); 1279ilg.Call(StringBuilder_get_Length); 1280ilg.Ldc(0); 1281ilg.If(Cmp.NotEqualTo); 1284ilg.Ldarg(0); 1285ilg.Ldstr(attribute.Name); 1289ilg.Ldstr(ns); 1299ilg.Ldloc("sb"); 1300ilg.Call(Object_ToString); 1309ilg.Call(XmlSerializationWriter_WriteAttribute); 1310ilg.EndIf(); 1315ilg.EndIf(); 1335ilg.Ldarg(0); 1336ilg.Ldloc(source.Source); 1337ilg.Ldarg(parent); 1338ilg.ConvertValue(ilg.GetArg(parent).ArgType, typeof(Object)); 1339ilg.Call(XmlSerializationWriter_WriteXmlAttribute); 1379LocalBuilder aLoc = ilg.GetLocal(aName); 1381ilg.Ldloc(aLoc); 1382ilg.Load(null); 1383ilg.If(Cmp.NotEqualTo); 1389SourceInfo choiceSourceInfo = new SourceInfo(choiceSource, null, choice.MemberInfo, null, ilg); 1393Label labelEnd = ilg.DefineLabel(); 1394Label labelTrue = ilg.DefineLabel(); 1395LocalBuilder cLoc = ilg.GetLocal(cName); 1396ilg.Ldloc(cLoc); 1397ilg.Load(null); 1398ilg.Beq(labelTrue); 1399ilg.Ldloc(cLoc); 1400ilg.Ldlen(); 1401ilg.Ldloc(aLoc); 1402ilg.Ldlen(); 1403ilg.Clt(); 1404ilg.Br(labelEnd); 1405ilg.MarkLabel(labelTrue); 1406ilg.Ldc(true); 1407ilg.MarkLabel(labelEnd); 1408ilg.If(); 1416ilg.Ldarg(0); 1417ilg.Ldstr(choice.Mapping.TypeDesc.FullName); 1418ilg.Ldstr(choice.MemberName); 1419ilg.Call(XmlSerializationWriter_CreateInvalidChoiceIdentifierValueException); 1420ilg.Throw(); 1421ilg.EndIf(); 1426ilg.EndIf(); 1440LocalBuilder eLoc = ilg.DeclareLocal(typeof(IEnumerator), "e"); 1451ilg.LoadAddress(ilg.GetVariable(arrayName)); 1455ilg.Load(ilg.GetVariable(arrayName)); 1465ilg.ConvertValue(arrayTypeDesc.Type, typeIEnumerable); 1468ilg.Call(getEnumeratorMethod); 1469ilg.ConvertValue(getEnumeratorMethod.ReturnType, typeof(IEnumerator)); 1470ilg.Stloc(eLoc); 1472ilg.Ldloc(eLoc); 1473ilg.Load(null); 1474ilg.If(Cmp.NotEqualTo); 1475ilg.WhileBegin(); 1479WriteElements(new SourceInfo(arrayNamePlusI, null, null, arrayElementTypeDesc.Type, ilg), choiceName + "i", elements, text, choice, arrayNamePlusA, true, true); 1481ilg.WhileBeginCondition(); // while (e.MoveNext()) 1489ilg.Ldloc(eLoc); 1490ilg.Call(IEnumerator_MoveNext); 1491ilg.WhileEndCondition(); 1492ilg.WhileEnd(); 1494ilg.EndIf(); // if (e != null) 1501LocalBuilder localI = ilg.DeclareOrGetLocal(typeof(Int32), iPlusArrayName); 1502ilg.For(localI, 0, ilg.GetLocal(arrayName)); 1509WriteElements(new SourceInfo(arrayNamePlusI, null, null, arrayElementTypeDesc.Type, ilg), choiceName + "i", elements, text, choice, arrayNamePlusA, true, arrayElementTypeDesc.IsNullable); 1512WriteElements(new SourceInfo(RaCodeGen.GetStringForArrayMember(arrayName, iPlusArrayName, arrayTypeDesc), null, null, arrayElementTypeDesc.Type, ilg), null, elements, text, choice, arrayNamePlusA, true, arrayElementTypeDesc.IsNullable); 1514ilg.EndFor(); 1530ilg.Load(null); 1531ilg.If(Cmp.NotEqualTo); 1555if (wroteFirstIf) ilg.InitElseIf(); 1556else { wroteFirstIf = true; ilg.InitIf(); } 1558ilg.Load(enumValue); 1559ilg.Ceq(); 1561Label labelFalse = ilg.DefineLabel(); 1562Label labelEnd = ilg.DefineLabel(); 1563ilg.Brfalse(labelFalse); 1565ilg.Load(null); 1566ilg.Cne(); 1567ilg.Br_S(labelEnd); 1568ilg.MarkLabel(labelFalse); 1569ilg.Ldc(false); 1570ilg.MarkLabel(labelEnd); 1572ilg.AndIf(); 1583if (wroteFirstIf) ilg.InitElseIf(); 1584else { wroteFirstIf = true; ilg.InitIf(); } 1587ilg.AndIf(); 1598else ilg.EndIf(); 1602if (elements.Length - anyCount > 0) ilg.InitElseIf(); 1603else ilg.InitIf(); 1608ilg.IsInst(typeof(XmlElement)); 1609ilg.Load(null); 1610ilg.Cne(); 1611ilg.AndIf(); 1613LocalBuilder elemLoc = ilg.DeclareLocal(typeof(XmlElement), "elem"); 1615ilg.Stloc(elemLoc); 1620if (c++ > 0) ilg.InitElseIf(); 1621else ilg.InitIf(); 1629labelFalse = ilg.DefineLabel(); 1630labelEnd = ilg.DefineLabel(); 1632ilg.Load(enumValue); 1633ilg.Bne(labelFalse); 1636ilg.Load(null); 1637ilg.Cne(); 1640ilg.Ldc(true); 1642ilg.Br(labelEnd); 1643ilg.MarkLabel(labelFalse); 1644ilg.Ldc(false); 1645ilg.MarkLabel(labelEnd); 1646ilg.AndIf(); 1648labelFalse = ilg.DefineLabel(); 1649labelEnd = ilg.DefineLabel(); 1664ilg.Ldloc(elemLoc); 1665ilg.Call(XmlNode_get_Name); 1666ilg.Ldstr(element.Name); 1674ilg.Call(String_op_Equality); 1675ilg.Brfalse(labelFalse); 1676ilg.Ldloc(elemLoc); 1677ilg.Call(XmlNode_get_NamespaceURI); 1678ilg.Ldstr(element.Namespace); 1679ilg.Call(String_op_Equality); 1680ilg.Br(labelEnd); 1681ilg.MarkLabel(labelFalse); 1682ilg.Ldc(false); 1683ilg.MarkLabel(labelEnd); 1684if (choice != null) ilg.If(); 1685else ilg.AndIf(); 1686WriteElement(new SourceInfo("elem", null, null, elemLoc.LocalType, ilg), element, arrayName, writeAccessors); 1689ilg.Else(); 1698ilg.Ldarg(0); 1699ilg.Ldstr(enumFullName); 1700ilg.Ldstr(choice.MemberName); 1701ilg.Ldloc(elemLoc); 1702ilg.Call(XmlNode_get_Name); 1703ilg.Ldloc(elemLoc); 1704ilg.Call(XmlNode_get_NamespaceURI); 1705ilg.Call(XmlSerializationWriter_CreateChoiceIdentifierValueException); 1706ilg.Throw(); 1707ilg.EndIf(); 1711ilg.Else(); 1714WriteElement(new SourceInfo("elem", null, null, elemLoc.LocalType, ilg), unnamedAny, arrayName, writeAccessors); 1724ilg.Ldarg(0); 1725ilg.Ldloc(elemLoc); 1740ilg.Call(XmlNode_get_Name); 1741ilg.Ldloc(elemLoc); 1742ilg.Call(XmlNode_get_NamespaceURI); 1743ilg.Call(XmlSerializationWriter_CreateUnknownAnyElementException); 1744ilg.Throw(); 1747ilg.EndIf(); 1753ilg.InitElseIf(); 1755ilg.AndIf(); 1767ilg.InitElseIf(); 1769ilg.Load(null); 1770ilg.AndIf(Cmp.NotEqualTo); 1773ilg.Else(); 1783ilg.Ldarg(0); 1785ilg.Call(XmlSerializationWriter_CreateUnknownTypeException); 1786ilg.Throw(); 1788ilg.EndIf(); 1792ilg.EndIf(); 1800ilg.Ldarg(0); 1814ilg.Call(XmlSerializationWriter_WriteValue); 1835ilg.Ldarg(0); 1836ilg.Call(XmlSerializationWriter_get_Writer); 1837ilg.Call(WriteTo); 1858ilg.Call(Nullable_get_HasValue); 1862ilg.Load(null); 1863ilg.Cne(); 1865ilg.If(); 1872ilg.Else(); 1875ilg.EndIf(); 1883ilg.EnterScope(); 1891ilg.Ldloc(ilg.GetLocal(arrayName)); 1892ilg.Load(null); 1893ilg.If(Cmp.NotEqualTo); 1900ilg.EndIf(); 1904ilg.EndIf(); 1907ilg.ExitScope(); 1933ilg.Ldarg(0); 1934ilg.Ldstr(name); 1936ilg.Ldstr(ns); 1941ilg.Ldc(element.IsNullable); 1944ilg.Ldc(false); 1951ilg.Call(methodBuilder); 1964Label ifLabel1 = ilg.DefineLabel(); 1965Label ifLabel2 = ilg.DefineLabel(); 1967ilg.IsInst(typeof(XmlNode)); 1968ilg.Brtrue(ifLabel1); 1970ilg.Load(null); 1971ilg.Ceq(); 1972ilg.Br(ifLabel2); 1973ilg.MarkLabel(ifLabel1); 1974ilg.Ldc(true); 1975ilg.MarkLabel(ifLabel2); 1976ilg.If(); 1980ilg.Else(); 1989ilg.Ldarg(0); 1991ilg.Call(XmlSerializationWriter_CreateInvalidAnyTypeException); 1992ilg.Throw(); 1994ilg.EndIf(); 2010ilg.Ldarg(0); 2012ilg.Ldstr(name); 2013ilg.Ldstr(ns); 2014ilg.Ldc(isNullable); 2015ilg.Ldc(isAny); 2016ilg.Call(XmlSerializationWriter_func); 2023Label labelEnd = ilg.DefineLabel(); 2024Label labelFalse = ilg.DefineLabel(); 2025Label labelTrue = ilg.DefineLabel(); 2029ilg.Brfalse(labelTrue); 2032ilg.Brfalse(labelFalse); 2041ilg.Call(String_get_Length); 2042ilg.Ldc(0); 2043ilg.Cne(); 2044ilg.Br(labelEnd); 2046ilg.MarkLabel(labelTrue); 2047ilg.Ldc(true); 2050ilg.MarkLabel(labelFalse); 2051ilg.Ldc(false); 2053ilg.MarkLabel(labelEnd); 2054ilg.If(); 2059ilg.Load(null); 2060ilg.Cne(); 2064ilg.Ldc(Convert.ChangeType(value, source.Type, CultureInfo.InvariantCulture)); 2065ilg.Cne(); 2070ilg.Ldc(value); 2079ilg.Call(op_Inequality); 2081ilg.Cne(); 2083ilg.If(); 2089Label labelFalse = ilg.DefineLabel(); 2090Label labelEnd = ilg.DefineLabel(); 2092ilg.Load(null); 2093ilg.Beq(labelFalse); 2096ilg.Ldc(false); 2097ilg.Ceq(); 2098ilg.Br(labelEnd); 2099ilg.MarkLabel(labelFalse); 2100ilg.Ldc(false); 2101ilg.MarkLabel(labelEnd); 2102ilg.If(); 2110ilg.Ldarg(0); 2111ilg.Ldstr(typeDesc.FullName); 2112ilg.Ldstr(choice.MemberName); 2113ilg.Ldstr(enumName); 2114ilg.Call(XmlSerializationWriter_CreateMismatchChoiceException); 2115ilg.Throw(); 2116ilg.EndIf(); 2120LocalBuilder local = ilg.GetLocal(source); 2122ilg.Load(local); 2123ilg.Load(null); 2124ilg.If(Cmp.EqualTo); 2126ilg.Else(); 2138ilg.Ldarg(0); 2140ilg.Call(XmlSerializationWriter_WriteNamespaceDeclarations); 2154RaCodeGen.WriteLocalDecl(variableName, new SourceInfo(initValue, initValue, null, type, ilg)); 2161RaCodeGen.WriteTypeCompare(variable, type, ilg); 2164RaCodeGen.WriteInstanceOf(source, type, ilg); 2167RaCodeGen.WriteArrayTypeCompare(variable, arrayType, ilg);