C# XmlBContext.moveBack方法代码示例

 /// <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 RulePriority lAcceptEnum_RulePriority(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       RulePriority res = RulePriority.defaultRulePriority;
     switch (ctxt.current()) {
     case 'V':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("erification")){
     res = RulePriority.aVerification;
     } else {
     ctxt.moveBack(1);
     res = RulePriority.aProcessing;
     } // If
     break;
     } // Case
     case 'U':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("pdate")){
     switch (ctxt.current()) {
     case 'O':
     {
     ctxt.advance();
     ctxt.accept2('U','T');
     res = RulePriority.aUpdateOUT;
     break;
     } // Case
     case 'I':
     {
     ctxt.advance();
     ctxt.acceptString ("NTERNAL");
     res = RulePriority.aUpdateINTERNAL;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2443)");
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = RulePriority.aProcessing;
     } // If
     break;
     } // Case
     case 'P':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("rocessing")){
     res = RulePriority.aProcessing;
     } else {
     ctxt.moveBack(1);
     res = RulePriority.aProcessing;
     } // If
     break;
     } // Case
     case 'C':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("leanUp")){
     res = RulePriority.aCleanUp;
     } else {
     ctxt.moveBack(1);
     res = RulePriority.aProcessing;
     } // If
     break;
     } // Case
     default:
     res = RulePriority.aProcessing;
     break;
     } // Switch
     return res;
 }

//.........这里部分代码省略.........
            ctxt.skipWhiteSpace();
            quoteChar = ctxt.acceptQuote();
            ctxt.skipTill (quoteChar);
            ctxt.accept(quoteChar);
            ctxt.skipWhiteSpace();
            } else {
            fl2121 = false ;
            } // If
            } // While
            ctxt.accept('>');
            // Indicator
            // Parse PC data
            this.setReference(acceptor.lAcceptPcData(ctxt, -1, '<',XmlBContext.WS_PRESERVE));
            // Regexp
            ctxt.skipWhiteSpace();
            ctxt.acceptString ("</reference>");
            } // If
            // End enclosed
            // Disjunct
            ctxt.skipWhiteSpace();
            // Nullable formula
            fl2124 = ctxt.getPtr();
            switch (ctxt.current()) {
            case '<':
            {
            ctxt.advance();
            switch (ctxt.current()) {
            case 'c':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("har-value")){
            indicator = 2123;
            } else {
            ctxt.moveBack(1);
            indicator = 2125;
            } // If
            break;
            } // Case
            case 'V':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("alues")){
            indicator = 2122;
            } else {
            ctxt.moveBack(1);
            indicator = 2125;
            } // If
            break;
            } // Case
            default:
            indicator = 2125;
            break;
            } // Switch
            break;
            } // Case
            default:
            indicator = 2125;
            break;
            } // Switch
            switch (indicator) {
            // Dispatch Lablel
            case 2122: {
            ctxt.moveBack(7);
            // Element Ref : Values
            ctxt.skipWhiteSpace();
            // If optional...

 /// <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 DBMessageType lAcceptEnum_DBMessageType(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       DBMessageType res = DBMessageType.defaultDBMessageType;
     switch (ctxt.current()) {
     case 'E':
     {
     ctxt.advance();
     if (ctxt.lookAhead3('U','R','O')){
     switch (ctxt.current()) {
     case 'R':
     {
     ctxt.advance();
     ctxt.acceptString ("ADIO");
     res = DBMessageType.aEURORADIO;
     break;
     } // Case
     case 'L':
     {
     ctxt.advance();
     ctxt.accept3('O','O','P');
     res = DBMessageType.aEUROLOOP;
     break;
     } // Case
     case 'B':
     {
     ctxt.advance();
     ctxt.acceptString ("ALISE");
     res = DBMessageType.aEUROBALISE;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2452)");
     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 ST_MODE lAcceptEnum_ST_MODE(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       ST_MODE res = ST_MODE.defaultST_MODE;
     switch (ctxt.current()) {
     case 'U':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('N')){
     res = ST_MODE.Mode_UN;
     } else {
     ctxt.moveBack(1);
     res = ST_MODE.Mode_NA;
     } // If
     break;
     } // Case
     case 'T':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('R')){
     res = ST_MODE.Mode_TR;
     } else {
     ctxt.moveBack(1);
     res = ST_MODE.Mode_NA;
     } // If
     break;
     } // Case
     case 'S':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'R':
     {
     ctxt.advance();
     res = ST_MODE.Mode_SR;
     break;
     } // Case
     case 'N':
     {
     ctxt.advance();
     res = ST_MODE.Mode_SN;
     break;
     } // Case
     case 'L':
     {
     ctxt.advance();
     res = ST_MODE.Mode_SL;
     break;
     } // Case
     case 'H':
     {
     ctxt.advance();
     res = ST_MODE.Mode_SH;
     break;
     } // Case
     case 'F':
     {
     ctxt.advance();
     res = ST_MODE.Mode_SF;
     break;
     } // Case
     case 'B':
     {
     ctxt.advance();
     res = ST_MODE.Mode_SB;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2424)");
     break;
     } // Switch
     break;
     } // Case
     case 'R':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('E')){
     res = ST_MODE.Mode_RE;
     } else {
     ctxt.moveBack(1);
     res = ST_MODE.Mode_NA;
     } // If
     break;
     } // Case
     case 'P':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'T':
     {
     ctxt.advance();
     res = ST_MODE.Mode_PT;
     break;
     } // Case
//.........这里部分代码省略.........

 /// <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 TypeSpec_ertms_type lAcceptEnum_TypeSpec_ertms_type(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       TypeSpec_ertms_type res = TypeSpec_ertms_type.defaultTypeSpec_ertms_type;
     switch (ctxt.current()) {
     case 't':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'i':
     {
     ctxt.advance();
     ctxt.acceptString ("me-or-date");
     res = TypeSpec_ertms_type.atime_or_date;
     break;
     } // Case
     case 'e':
     {
     ctxt.advance();
     ctxt.accept2('x','t');
     res = TypeSpec_ertms_type.atext;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2246)");
     break;
     } // Switch
     break;
     } // Case
     case 's':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("peed")){
     res = TypeSpec_ertms_type.aspeed;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'q':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ualifier")){
     res = TypeSpec_ertms_type.aqualifier;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'm':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("iscellaneous")){
     res = TypeSpec_ertms_type.amiscellaneous;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'l':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ength")){
     res = TypeSpec_ertms_type.alength;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'i':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("dentity-number")){
     res = TypeSpec_ertms_type.aidentity_number;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'g':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("radient")){
     res = TypeSpec_ertms_type.agradient;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     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 Message_media lAcceptEnum_Message_media(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       Message_media res = Message_media.defaultMessage_media;
     switch (ctxt.current()) {
     case 'R':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'I':
     {
     ctxt.advance();
     ctxt.accept('U');
     res = Message_media.aRIU;
     break;
     } // Case
     case 'B':
     {
     ctxt.advance();
     ctxt.accept('C');
     switch (ctxt.current()) {
     case ',':
     {
     ctxt.advance();
     if (ctxt.lookAheadString(" RIU")){
     res = Message_media.aRBC_RIU;
     } else {
     ctxt.moveBack(1);
     res = Message_media.aRBC;
     } // If
     break;
     } // Case
     default:
     res = Message_media.aRBC;
     break;
     } // Switch
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2232)");
     break;
     } // Switch
     break;
     } // Case
     case 'L':
     {
     ctxt.advance();
     if (ctxt.lookAhead3('o','o','p')){
     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
//.........这里部分代码省略.........

 /// <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;
//.........这里部分代码省略.........

 /// <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 meaning_type lAcceptEnum_meaning_type(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       meaning_type res = meaning_type.defaultmeaning_type;
     switch (ctxt.current()) {
     case 'u':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("nknown")){
     res = meaning_type.aunknown;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'i':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('n')){
     switch (ctxt.current()) {
     case 'v':
     {
     ctxt.advance();
     ctxt.acceptString ("alid");
     res = meaning_type.ainvalid;
     break;
     } // Case
     case 'f':
     {
     ctxt.advance();
     ctxt.acceptString ("inite");
     res = meaning_type.ainfinite;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2259)");
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'e':
     {
     ctxt.advance();
     if (ctxt.lookAhead3('n','u','m')){
     res = meaning_type.aenum;
     } 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 maximum_Value lAcceptEnum_maximum_Value(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       maximum_Value res = maximum_Value.defaultmaximum_Value;
     switch (ctxt.current()) {
     case 'E':
     {
     ctxt.advance();
     res = maximum_Value.aE;
     break;
     } // Case
     case '7':
     {
     ctxt.advance();
     res = maximum_Value.aC_7;
     break;
     } // Case
     case '2':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('5')){
     switch (ctxt.current()) {
     case '5':
     {
     ctxt.advance();
     res = maximum_Value.a255;
     break;
     } // Case
     case '4':
     {
     ctxt.advance();
     res = maximum_Value.a254;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2266)");
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case '1':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case '5':
     {
     ctxt.advance();
     res = maximum_Value.a15;
     break;
     } // Case
     case '2':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case '7':
     {
     ctxt.advance();
     res = maximum_Value.a127;
     break;
     } // Case
     case '6':
     {
     ctxt.advance();
     res = maximum_Value.a126;
     break;
     } // Case
     case '5':
     {
     ctxt.advance();
     res = maximum_Value.a125;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2273)");
     break;
     } // Switch
     break;
     } // Case
     case '1':
     {
     ctxt.advance();
     res = maximum_Value.a11;
     break;
     } // Case
     case '0':
     {
     ctxt.advance();
     ctxt.accept2('2','2');
     res = maximum_Value.a1022;
     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 ExpectationKind lAcceptEnum_ExpectationKind(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       ExpectationKind res = ExpectationKind.defaultExpectationKind;
     switch (ctxt.current()) {
     case 'I':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("nstantaneous")){
     res = ExpectationKind.aInstantaneous;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'C':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ontinuous")){
     res = ExpectationKind.aContinuous;
     } 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 SPEC_IMPLEMENTED_ENUM lAcceptEnum_SPEC_IMPLEMENTED_ENUM(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       SPEC_IMPLEMENTED_ENUM res = SPEC_IMPLEMENTED_ENUM.defaultSPEC_IMPLEMENTED_ENUM;
     switch (ctxt.current()) {
     case 'N':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'o':
     {
     ctxt.advance();
     ctxt.acceptString ("tImplementable");
     res = SPEC_IMPLEMENTED_ENUM.Impl_NotImplementable;
     break;
     } // Case
     case 'e':
     {
     ctxt.advance();
     ctxt.acceptString ("wRevisionAvailable");
     res = SPEC_IMPLEMENTED_ENUM.Impl_NewRevisionAvailable;
     break;
     } // Case
     case 'A':
     {
     ctxt.advance();
     res = SPEC_IMPLEMENTED_ENUM.Impl_NA;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2397)");
     break;
     } // Switch
     break;
     } // Case
     case 'I':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("mplemented")){
     res = SPEC_IMPLEMENTED_ENUM.Impl_Implemented;
     } else {
     ctxt.moveBack(1);
     res = SPEC_IMPLEMENTED_ENUM.Impl_NA;
     } // If
     break;
     } // Case
     default:
     res = SPEC_IMPLEMENTED_ENUM.Impl_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 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;
 }