C# XmlBContext.lookAhead2方法代码示例

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static resolution_formula_Value lAcceptEnum_resolution_formula_Value(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       resolution_formula_Value res = resolution_formula_Value.defaultresolution_formula_Value;
     switch (ctxt.current()) {
     case 'i':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ntegers")){
     res = resolution_formula_Value.aintegers;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'N':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("umber")){
     switch (ctxt.current()) {
     case 's':
     {
     ctxt.advance();
     res = resolution_formula_Value.aNumbers;
     break;
     } // Case
     default:
     res = resolution_formula_Value.aNumber;
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'B':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('i')){
     switch (ctxt.current()) {
     case 't':
     {
     ctxt.advance();
     ctxt.accept3('s','e','t');
     res = resolution_formula_Value.aBitset;
     break;
     } // Case
     case 'n':
     {
     ctxt.advance();
     ctxt.acceptString ("ary Coded Decimal");
     res = resolution_formula_Value.aBinary_Coded_Decimal;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2297)");
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case '5':
     {
     ctxt.advance();
     res = resolution_formula_Value.aC_5;
     break;
     } // Case
     case '1':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case '0':
     {
     ctxt.advance();
     res = resolution_formula_Value.a10;
     break;
     } // Case
     default:
     res = resolution_formula_Value.aC_1;
     break;
     } // Switch
     break;
     } // Case
     case '0':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('.','0')){
     switch (ctxt.current()) {
     case '5':
//.........这里部分代码省略.........

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static Paragraph_scope lAcceptEnum_Paragraph_scope(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       Paragraph_scope res = Paragraph_scope.defaultParagraph_scope;
     switch (ctxt.current()) {
     case 'T':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("RACK")){
     res = Paragraph_scope.aTRACK;
     } else {
     ctxt.moveBack(1);
     res = Paragraph_scope.aOBU_AND_TRACK;
     } // If
     break;
     } // Case
     case 'R':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("OLLING_STOCK")){
     res = Paragraph_scope.aROLLING_STOCK;
     } else {
     ctxt.moveBack(1);
     res = Paragraph_scope.aOBU_AND_TRACK;
     } // If
     break;
     } // Case
     case 'O':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('B','U')){
     switch (ctxt.current()) {
     case '_':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("AND_TRACK")){
     res = Paragraph_scope.aOBU_AND_TRACK;
     } else {
     ctxt.moveBack(1);
     res = Paragraph_scope.aOBU;
     } // If
     break;
     } // Case
     default:
     res = Paragraph_scope.aOBU;
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = Paragraph_scope.aOBU_AND_TRACK;
     } // If
     break;
     } // Case
     case 'F':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("LAGS")){
     res = Paragraph_scope.aFLAGS;
     } else {
     ctxt.moveBack(1);
     res = Paragraph_scope.aOBU_AND_TRACK;
     } // If
     break;
     } // Case
     default:
     res = Paragraph_scope.aOBU_AND_TRACK;
     break;
     } // Switch
     return res;
 }

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static resolution_formula_units lAcceptEnum_resolution_formula_units(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       resolution_formula_units res = resolution_formula_units.defaultresolution_formula_units;
     switch (ctxt.current()) {
     case 't':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ext-string-element")){
     res = resolution_formula_units.text_string_element;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 's':
     {
     ctxt.advance();
     res = resolution_formula_units.s;
     break;
     } // Case
     case 'q':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("_scale")){
     res = resolution_formula_units.q_scale;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'm':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 's':
     {
     ctxt.advance();
     res = resolution_formula_units.ms;
     break;
     } // Case
     case '/':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('s','2')){
     res = resolution_formula_units.m_s2;
     } else {
     ctxt.moveBack(1);
     res = resolution_formula_units.m;
     } // If
     break;
     } // Case
     default:
     res = resolution_formula_units.m;
     break;
     } // Switch
     break;
     } // Case
     case 'k':
     {
     ctxt.advance();
     if (ctxt.lookAhead3('m','/','h')){
     res = resolution_formula_units.km_h;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'b':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'y':
     {
     ctxt.advance();
     ctxt.accept2('t','e');
     res = resolution_formula_units.abyte;
     break;
     } // Case
     case 'i':
     {
     ctxt.advance();
     ctxt.accept('t');
     res = resolution_formula_units.abit;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2288)");
     break;
     } // Switch
     break;
//.........这里部分代码省略.........

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static Namable lAccept_Poly_Namable(XmlBContext ctxt, 
                   string  endingTag)
 {
     char quoteChar;
     Namable res = null;
     ctxt.skipWhiteSpace();
     ctxt.acceptString ("xsi:type=");
     quoteChar = ctxt.acceptQuote();
     switch (ctxt.current()) {
     case 'V':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ariable")){
     ctxt.accept(quoteChar);
     res = lAccept_Variable(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'T':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'r':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("anslation")){
     switch (ctxt.current()) {
     case 'D':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ictionary")){
     ctxt.accept(quoteChar);
     res = lAccept_TranslationDictionary(ctxt, endingTag);
     } else {
     ctxt.accept(quoteChar);
     res = lAccept_Translation(ctxt, endingTag);
     } // If
     break;
     } // Case
     default:
     ctxt.accept(quoteChar);
     res = lAccept_Translation(ctxt, endingTag);
     break;
     } // Switch
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'e':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("stCase")){
     ctxt.accept(quoteChar);
     res = lAccept_TestCase(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     default:
     res = null;
     break;
     } // Switch
     break;
     } // Case
     case 'S':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'u':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('b','S')){
     switch (ctxt.current()) {
     case 't':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('e','p')){
     ctxt.accept(quoteChar);
     res = lAccept_SubStep(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'e':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("quence")){
     ctxt.accept(quoteChar);
     res = lAccept_SubSequence(ctxt, endingTag);
     } else {
     res = null;
//.........这里部分代码省略.........

        /// <remarks>This method is used by XMLBooster-generated code
        /// internally. Please refrain from using it, as it
        /// might produce unexpected results, and might change
        /// or even disappear in the future.</remarks>
        public override void parse(XmlBContext ctxt,  string  endingTag)
        {
            #pragma warning disable 0168, 0219
            int indicator = 0;
            char quoteChar;
             string  tempStr = null;
            bool fl890;
            bool fl891;
            bool fl892;
            bool fl893;
            bool fl894;
            bool fl895;
            bool fl896;
            bool fl897;
            bool fl898;
            bool fl899;
            bool fl900;
            #pragma warning restore 0168, 0219

            ctxt.skipWhiteSpace();
            {
            // Accept Attributes
            fl890 = false ;
            fl891 = false ;
            fl892 = false ;
            fl893 = false ;
            fl894 = false ;
            fl895 = false ;
            fl896 = false ;
            fl897 = false ;
            fl898 = false ;
            fl899 = false ;
            fl900 = true ;
            while (fl900) { // BeginLoop
            switch (ctxt.current()) {
            case 'R':
            {
            ctxt.advance();
            if (ctxt.lookAhead2('B','C')){
            switch (ctxt.current()) {
            case '_':
            {
            ctxt.advance();
            if (ctxt.lookAhead3('I','D','=')){
            indicator = 897;
            } else {
            indicator = 901;
            } // If
            break;
            } // Case
            case 'P':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("hone=")){
            indicator = 898;
            } else {
            indicator = 901;
            } // If
            break;
            } // Case
            default:
            indicator = 901;
            break;
            } // Switch
            } else {
            indicator = 901;
            } // If
            break;
            } // Case
            case 'Q':
            {
            ctxt.advance();
            if (ctxt.lookAhead2('_','D')){
            switch (ctxt.current()) {
            case 'L':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("RBG=")){
            indicator = 896;
            } else {
            indicator = 901;
            } // If
            break;
            } // Case
            case 'I':
            {
            ctxt.advance();
            if (ctxt.lookAhead1('R')){
            switch (ctxt.current()) {
            case 'T':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("RAIN=")){
            indicator = 895;
            } else {
            indicator = 901;
//.........这里部分代码省略.........

        /// <remarks>This method is used by XMLBooster-generated code
        /// internally. Please refrain from using it, as it
        /// might produce unexpected results, and might change
        /// or even disappear in the future.</remarks>
        public override void parse(XmlBContext ctxt,  string  endingTag)
        {
            #pragma warning disable 0168, 0219
            int indicator = 0;
            char quoteChar;
             string  tempStr = null;
            bool fl1405;
            bool fl1406;
            bool fl1407;
            bool fl1408;
            bool fl1409;
            bool fl1410;
            bool fl1411;
            bool fl1412;
            bool fl1413;
            bool fl1414;
            bool fl1415;
            bool fl1416;
            bool fl1417;
            bool fl1418;
            #pragma warning restore 0168, 0219

            ctxt.skipWhiteSpace();
            {
            // Accept Attributes
            fl1405 = false ;
            fl1406 = false ;
            fl1407 = false ;
            fl1408 = false ;
            fl1409 = false ;
            fl1410 = false ;
            fl1411 = false ;
            fl1412 = false ;
            fl1413 = false ;
            fl1414 = false ;
            fl1415 = false ;
            fl1416 = false ;
            fl1417 = false ;
            fl1418 = true ;
            while (fl1418) { // BeginLoop
            switch (ctxt.current()) {
            case 'U':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("pdates=")){
            indicator = 1416;
            } else {
            indicator = 1419;
            } // If
            break;
            } // Case
            case 'T':
            {
            ctxt.advance();
            switch (ctxt.current()) {
            case 'r':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("anslat")){
            switch (ctxt.current()) {
            case 'i':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("onRequired=")){
            indicator = 1412;
            } else {
            indicator = 1419;
            } // If
            break;
            } // Case
            case 'e':
            {
            ctxt.advance();
            if (ctxt.lookAhead2('d','=')){
            indicator = 1413;
            } else {
            indicator = 1419;
            } // If
            break;
            } // Case
            default:
            indicator = 1419;
            break;
            } // Switch
            } else {
            indicator = 1419;
            } // If
            break;
            } // Case
            case 'C':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("S_Order=")){
            indicator = 1405;
            } else {
            indicator = 1419;
//.........这里部分代码省略.........

        /// <summary>Utility function which parse a PCDATA component 
        /// from a context. It takes the entities defined in the
        /// in the configuration into account.</summary>
        /// <param name="ctxt">the context from which the data must be 
        ///        parsed</param>
        /// <param name="maxLen">the maximal number of characters that 
        ///        can be read.</param>
        /// <param name="closingCh">a character on which parsing must stop
        ///        in addition to the standard &lt; character.</param>
        /// <param name="wsMode">indicates PRESERVE (default), REPLACE or COLLAPSE.</param>
        public static string lAcceptPcData(XmlBContext ctxt, 
                                   int maxLen,
                                   char closingCh,
                                   int wsMode)
        {
            char ch;
            char lastch = '.';
            System.Text.StringBuilder buff;
             string  res;

              buff = new System.Text.StringBuilder();
              bool go_on = true;
              while (go_on)
            {
              go_on = false;
              while ((ctxt.current() != '<') && (ctxt.current() != closingCh)) // while 1
            {
            ch = ctxt.current();
            ctxt.advance();
            if (ch == '&'){
            ch = lAcceptPcDataChr(ctxt);
            } else {
            if (wsMode >= WS_REPLACE){
            if (ch == '\t' || ch == '\n' || ch == '\r'){
            ch = ' ';
            } // If
            if (wsMode == WS_COLLAPSE){
            if ((ch == ' ') && ((lastch == ' ') || (buff.Length == 0))){
            ch = (char)0;
            } else {
            lastch = ch;
            } // If
            } else {
            lastch = ch;
            } // If
            } // If
            } // If
            if (ch != '\0'){
            buff.Append (ch);
            } // If
            }
            // end while
            if (ctxt.current() == '<'){
            if (ctxt.lookAheadString("<![CDATA[")){
             string  cdata = ctxt.acceptUntil("]]>", true);
            buff.Append (cdata);
            go_on = true;
            } else {
            if (ctxt.lookAhead2('<','?')){
            ctxt.skipTill ('?');
            ctxt.accept2('?','>');
            go_on = true;
            } else {
            } // If
            } // If
            } // If
            }
            if (wsMode == WS_COLLAPSE && lastch == ' ' && buff. Length > 0){
            res = buff.ToString (0, buff.Length -1);
            } else {
            res = buff.ToString();
            } // If
            if ((maxLen > 0) && (res.Length > maxLen)){
            ctxt.recoverableFail ("Maximum length exceeded");
            } // If
            return res;
        }

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static ChangeOperationEnum lAcceptEnum_ChangeOperationEnum(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       ChangeOperationEnum res = ChangeOperationEnum.defaultChangeOperationEnum;
     switch (ctxt.current()) {
     case 'R':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("emove")){
     res = ChangeOperationEnum.aRemove;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'C':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("hange")){
     res = ChangeOperationEnum.aChange;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'A':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('d','d')){
     res = ChangeOperationEnum.aAdd;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     default:
     res = 0;
     break;
     } // Switch
     return res;
 }

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static ST_INTERFACE lAcceptEnum_ST_INTERFACE(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       ST_INTERFACE res = ST_INTERFACE.defaultST_INTERFACE;
     switch (ctxt.current()) {
     case 'T':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('I','U')){
     res = ST_INTERFACE.StInterface_TIU;
     } else {
     ctxt.moveBack(1);
     res = ST_INTERFACE.StInterface_NA;
     } // If
     break;
     } // Case
     case 'R':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('T','M')){
     res = ST_INTERFACE.StInterface_RTM;
     } else {
     ctxt.moveBack(1);
     res = ST_INTERFACE.StInterface_NA;
     } // If
     break;
     } // Case
     case 'N':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('A')){
     res = ST_INTERFACE.StInterface_NA;
     } else {
     ctxt.moveBack(1);
     res = ST_INTERFACE.StInterface_NA;
     } // If
     break;
     } // Case
     case 'J':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('R','U')){
     res = ST_INTERFACE.StInterface_JRU;
     } else {
     ctxt.moveBack(1);
     res = ST_INTERFACE.StInterface_NA;
     } // If
     break;
     } // Case
     case 'D':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('M','I')){
     res = ST_INTERFACE.StInterface_DMI;
     } else {
     ctxt.moveBack(1);
     res = ST_INTERFACE.StInterface_NA;
     } // If
     break;
     } // Case
     default:
     res = ST_INTERFACE.StInterface_NA;
     break;
     } // Switch
     return res;
 }

 public static IXmlBBase accept(XmlBContext ctxt)
 {
     IXmlBBase res = null;
     ctxt.skipWhiteSpace();
     switch (ctxt.current()) {
     case '<':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'V':
     {
     ctxt.advance();
     ctxt.acceptString ("ariable");
       res =  lAccept_Variable(ctxt, "</Variable>");
     break;
     } // Case
     case 'T':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'r':
     {
     ctxt.advance();
     ctxt.acceptString ("anslation");
     switch (ctxt.current()) {
     case 'D':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ictionary")){
       res =  lAccept_TranslationDictionary(ctxt, "</TranslationDictionary>");
     } else {
       res =  lAccept_Translation(ctxt, "</Translation>");
     } // If
     break;
     } // Case
     default:
       res =  lAccept_Translation(ctxt, "</Translation>");
     break;
     } // Switch
     break;
     } // Case
     case 'e':
     {
     ctxt.advance();
     ctxt.acceptString ("stCase");
       res =  lAccept_TestCase(ctxt, "</TestCase>");
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2672)");
     break;
     } // Switch
     break;
     } // Case
     case 'S':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'u':
     {
     ctxt.advance();
     ctxt.accept2('b','S');
     switch (ctxt.current()) {
     case 't':
     {
     ctxt.advance();
     ctxt.accept2('e','p');
       res =  lAccept_SubStep(ctxt, "</SubStep>");
     break;
     } // Case
     case 'e':
     {
     ctxt.advance();
     ctxt.acceptString ("quence");
       res =  lAccept_SubSequence(ctxt, "</SubSequence>");
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2677)");
     break;
     } // Switch
     break;
     } // Case
     case 't':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'r':
     {
     ctxt.advance();
     ctxt.acceptString ("ucture");
     switch (ctxt.current()) {
     case 'R':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('e','f')){
       res =  lAccept_StructureRef(ctxt, "</StructureRef>");
     } else {
       res =  lAccept_Structure(ctxt, "</Structure>");
     } // If
//.........这里部分代码省略.........

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static ST_IO lAcceptEnum_ST_IO(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       ST_IO res = ST_IO.defaultST_IO;
     switch (ctxt.current()) {
     case 'O':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('u','t')){
     res = ST_IO.StIO_Out;
     } else {
     ctxt.moveBack(1);
     res = ST_IO.StIO_NA;
     } // If
     break;
     } // Case
     case 'N':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('A')){
     res = ST_IO.StIO_NA;
     } else {
     ctxt.moveBack(1);
     res = ST_IO.StIO_NA;
     } // If
     break;
     } // Case
     case 'I':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('n')){
     res = ST_IO.StIO_In;
     } else {
     ctxt.moveBack(1);
     res = ST_IO.StIO_NA;
     } // If
     break;
     } // Case
     default:
     res = ST_IO.StIO_NA;
     break;
     } // Switch
     return res;
 }

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static MessageDirectionEnumType lAcceptEnum_MessageDirectionEnumType(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       MessageDirectionEnumType res = MessageDirectionEnumType.defaultMessageDirectionEnumType;
     switch (ctxt.current()) {
     case 'T':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('r','a')){
     switch (ctxt.current()) {
     case 'i':
     {
     ctxt.advance();
     ctxt.acceptString ("nToTrack");
     res = MessageDirectionEnumType.aTrainToTrack;
     break;
     } // Case
     case 'c':
     {
     ctxt.advance();
     ctxt.acceptString ("kToTrain");
     res = MessageDirectionEnumType.aTrackToTrain;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2392)");
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     default:
     res = 0;
     break;
     } // Switch
     return res;
 }

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static MessageEnumType lAcceptEnum_MessageEnumType(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       MessageEnumType res = MessageEnumType.defaultMessageEnumType;
     switch (ctxt.current()) {
     case 'V':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("alidatedTrainData")){
     res = MessageEnumType.aValidatedTrainData;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'U':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("nconditionalEmergencyStop")){
     res = MessageEnumType.aUnconditionalEmergencyStop;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'T':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('r','a')){
     switch (ctxt.current()) {
     case 'i':
     {
     ctxt.advance();
     ctxt.accept('n');
     switch (ctxt.current()) {
     case '_':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'T':
     {
     ctxt.advance();
     ctxt.acceptString ("erminationOfACommunicationSession");
     res = MessageEnumType.aTrain_TerminationOfACommunicationSession;
     break;
     } // Case
     case 'S':
     {
     ctxt.advance();
     ctxt.acceptString ("essionEstablished");
     res = MessageEnumType.aTrain_SessionEstablished;
     break;
     } // Case
     case 'N':
     {
     ctxt.advance();
     ctxt.acceptString ("oCompatibleVersionSupported");
     res = MessageEnumType.aTrain_NoCompatibleVersionSupported;
     break;
     } // Case
     case 'I':
     {
     ctxt.advance();
     ctxt.acceptString ("nitiationOfACommunicationSession");
     res = MessageEnumType.aTrain_InitiationOfACommunicationSession;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2321)");
     break;
     } // Switch
     break;
     } // Case
     case 'R':
     {
     ctxt.advance();
     ctxt.acceptString ("ejected");
     res = MessageEnumType.aTrainRejected;
     break;
     } // Case
     case 'P':
     {
     ctxt.advance();
     ctxt.acceptString ("ositionReport");
     res = MessageEnumType.aTrainPositionReport;
     break;
     } // Case
     case 'A':
     {
     ctxt.advance();
     ctxt.acceptString ("ccepted");
     res = MessageEnumType.aTrainAccepted;
//.........这里部分代码省略.........

//.........这里部分代码省略.........
     res = Message_media.aLoop;
     } else {
     ctxt.moveBack(1);
     res = Message_media.aAny_;
     } // If
     break;
     } // Case
     case 'B':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("alise")){
     switch (ctxt.current()) {
     case ',':
     {
     ctxt.advance();
     if (ctxt.lookAhead1(' ')){
     switch (ctxt.current()) {
     case 'l':
     {
     ctxt.advance();
     ctxt.acceptString ("oop, RIU");
     res = Message_media.aBalise_loop_RIU;
     break;
     } // Case
     case 'R':
     {
     ctxt.advance();
     ctxt.accept2('B','C');
     switch (ctxt.current()) {
     case ',':
     {
     ctxt.advance();
     if (ctxt.lookAheadString(" RIU")){
     res = Message_media.aBalise_RBC_RIU;
     } else {
     ctxt.moveBack(1);
     res = Message_media.aBalise_RBC;
     } // If
     break;
     } // Case
     default:
     res = Message_media.aBalise_RBC;
     break;
     } // Switch
     break;
     } // Case
     case 'L':
     {
     ctxt.advance();
     ctxt.accept3('o','o','p');
     res = Message_media.aBalise_loop;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2240)");
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = Message_media.aBalise;
     } // If
     break;
     } // Case
     default:
     res = Message_media.aBalise;
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = Message_media.aAny_;
     } // If
     break;
     } // Case
     case 'A':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('n','y')){
     switch (ctxt.current()) {
     case ' ':
     {
     ctxt.advance();
     res = Message_media.aAny_;
     break;
     } // Case
     default:
     res = Message_media.aAny;
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = Message_media.aAny_;
     } // If
     break;
     } // Case
     default:
     res = Message_media.aAny_;
     break;
     } // Switch
     return res;
 }

 /// <remarks>This method is used by XMLBooster-generated code
 /// internally. Please refrain from using it, as it
 /// might produce unexpected results, and might change
 /// or even disappear in the future.</remarks>
 public static ReqRelated lAccept_Poly_ReqRelated(XmlBContext ctxt, 
                   string  endingTag)
 {
     char quoteChar;
     ReqRelated res = null;
     ctxt.skipWhiteSpace();
     ctxt.acceptString ("xsi:type=");
     quoteChar = ctxt.acceptQuote();
     switch (ctxt.current()) {
     case 'V':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ariable")){
     ctxt.accept(quoteChar);
     res = lAccept_Variable(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'T':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("estCase")){
     ctxt.accept(quoteChar);
     res = lAccept_TestCase(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'S':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('t')){
     switch (ctxt.current()) {
     case 'r':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ucture")){
     switch (ctxt.current()) {
     case 'E':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("lement")){
     ctxt.accept(quoteChar);
     res = lAccept_StructureElement(ctxt, endingTag);
     } else {
     ctxt.accept(quoteChar);
     res = lAccept_Structure(ctxt, endingTag);
     } // If
     break;
     } // Case
     default:
     ctxt.accept(quoteChar);
     res = lAccept_Structure(ctxt, endingTag);
     break;
     } // Switch
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'a':
     {
     ctxt.advance();
     if (ctxt.lookAhead2('t','e')){
     switch (ctxt.current()) {
     case 'M':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("achine")){
     ctxt.accept(quoteChar);
     res = lAccept_StateMachine(ctxt, endingTag);
     } else {
     ctxt.accept(quoteChar);
     res = lAccept_State(ctxt, endingTag);
     } // If
     break;
     } // Case
     default:
     ctxt.accept(quoteChar);
     res = lAccept_State(ctxt, endingTag);
     break;
     } // Switch
     } else {
     res = null;
     } // If
     break;
     } // Case
     default:
     res = null;
     break;
     } // Switch
     } else {
     res = null;
//.........这里部分代码省略.........