C# XmlBContext.current方法代码示例

 /// <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_LEVEL lAcceptEnum_ST_LEVEL(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       ST_LEVEL res = ST_LEVEL.defaultST_LEVEL;
     switch (ctxt.current()) {
     case 'N':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('A')){
     res = ST_LEVEL.StLevel_NA;
     } else {
     ctxt.moveBack(1);
     res = ST_LEVEL.StLevel_NA;
     } // If
     break;
     } // Case
     case 'L':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'N':
     {
     ctxt.advance();
     ctxt.accept2('T','C');
     res = ST_LEVEL.StLevel_LNTC;
     break;
     } // Case
     case '3':
     {
     ctxt.advance();
     res = ST_LEVEL.StLevel_L3;
     break;
     } // Case
     case '2':
     {
     ctxt.advance();
     res = ST_LEVEL.StLevel_L2;
     break;
     } // Case
     case '1':
     {
     ctxt.advance();
     res = ST_LEVEL.StLevel_L1;
     break;
     } // Case
     case '0':
     {
     ctxt.advance();
     res = ST_LEVEL.StLevel_L0;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2414)");
     break;
     } // Switch
     break;
     } // Case
     default:
     res = ST_LEVEL.StLevel_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 Type lAccept_Poly_Type(XmlBContext ctxt, 
                   string  endingTag)
 {
     char quoteChar;
     Type res = null;
     ctxt.skipWhiteSpace();
     ctxt.acceptString ("xsi:type=");
     quoteChar = ctxt.acceptQuote();
     switch (ctxt.current()) {
     case 'S':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('t')){
     switch (ctxt.current()) {
     case 'r':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ucture")){
     ctxt.accept(quoteChar);
     res = lAccept_Structure(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'a':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("teMachine")){
     ctxt.accept(quoteChar);
     res = lAccept_StateMachine(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     default:
     res = null;
     break;
     } // Switch
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'R':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ange")){
     ctxt.accept(quoteChar);
     res = lAccept_Range(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'F':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("unction")){
     ctxt.accept(quoteChar);
     res = lAccept_Function(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'E':
     {
     ctxt.advance();
     if (ctxt.lookAhead3('n','u','m')){
     ctxt.accept(quoteChar);
     res = lAccept_Enum(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     case 'C':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("ollection")){
     ctxt.accept(quoteChar);
     res = lAccept_Collection(ctxt, endingTag);
     } else {
     res = null;
     } // If
     break;
     } // Case
     default:
     res = null;
     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 override void parse(XmlBContext ctxt,  string  endingTag)
        {
            #pragma warning disable 0168, 0219
            int indicator = 0;
            char quoteChar;
             string  tempStr = null;
            bool fl911;
            bool fl912;
            bool fl913;
            bool fl914;
            bool fl915;
            #pragma warning restore 0168, 0219

            ctxt.skipWhiteSpace();
            {
            // Accept Attributes
            fl911 = false ;
            fl912 = false ;
            fl913 = false ;
            fl914 = false ;
            fl915 = true ;
            while (fl915) { // BeginLoop
            switch (ctxt.current()) {
            case 'U':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("pdates=")){
            indicator = 913;
            } else {
            indicator = 916;
            } // If
            break;
            } // Case
            case 'N':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("ame=")){
            indicator = 911;
            } else {
            indicator = 916;
            } // If
            break;
            } // Case
            case 'I':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("sRemoved=")){
            indicator = 914;
            } else {
            indicator = 916;
            } // If
            break;
            } // Case
            case 'G':
            {
            ctxt.advance();
            if (ctxt.lookAheadString("uid=")){
            indicator = 912;
            } else {
            indicator = 916;
            } // If
            break;
            } // Case
            default:
            indicator = 916;
            break;
            } // Switch
            switch (indicator) {
            case 911: {
            // Handling attribute Name
            // Also handles alien attributes with prefix Name
            if (fl911){
            ctxt.fail ("Duplicate attribute: Name");
            } // If
            fl911 = true ;
            quoteChar = ctxt.acceptQuote();
            this.setName((acceptor.lAcceptPcData(ctxt,-1, quoteChar, XmlBContext.WS_PRESERVE)));
            ctxt.accept(quoteChar);
            ctxt.skipWhiteSpace();
            break;
            } // End of dispatch label
            case 912: {
            // Handling attribute Guid
            // Also handles alien attributes with prefix Guid
            if (fl912){
            ctxt.fail ("Duplicate attribute: Guid");
            } // If
            fl912 = true ;
            quoteChar = ctxt.acceptQuote();
            this.setGuid((acceptor.lAcceptPcData(ctxt,-1, quoteChar, XmlBContext.WS_PRESERVE)));
            ctxt.accept(quoteChar);
            ctxt.skipWhiteSpace();
            break;
            } // End of dispatch label
            case 913: {
            // Handling attribute Updates
//.........这里部分代码省略.........

 /// <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 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 TimeDelay lAcceptEnum_TimeDelay(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       TimeDelay res = TimeDelay.defaultTimeDelay;
     switch (ctxt.current()) {
     case 'N':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("otDelayed")){
     res = TimeDelay.aNotDelayed;
     } else {
     ctxt.moveBack(1);
     res = 0;
     } // If
     break;
     } // Case
     case 'D':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("elayed")){
     res = TimeDelay.aDelayed;
     } 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 override void parseBody(XmlBContext ctxt)
        {
            #pragma warning disable 0168, 0219
            int indicator=0;
            char quoteChar;
             string  tempStr;
            #pragma warning restore 0168, 0219
            bool fl644;
            Rule fl646;
            bool fl657;
            Procedure fl659;
            StructureElement fl671;
            bool fl682;
            StateMachine fl684;
            bool fl695;
            StructureRef fl697;

            ctxt.skipWhiteSpace();
            base.parseBody(ctxt);
            ctxt.skipWhiteSpace();
            // Optional Enclosed
            if (ctxt.lookAheadOpeningTag("<Rules")){
            ctxt.skipWhiteSpace();
            fl644 = true ;
            while (fl644) { // BeginLoop
            ctxt.skipWhiteSpace();
            if (ctxt.isAlNum()){
            ctxt.skipTill ('=');
            ctxt.advance();
            ctxt.skipWhiteSpace();
            quoteChar = ctxt.acceptQuote();
            ctxt.skipTill (quoteChar);
            ctxt.accept(quoteChar);
            ctxt.skipWhiteSpace();
            } else {
            fl644 = false ;
            } // If
            } // While
            if (ctxt.current() == '/'){
            ctxt.advance();
            ctxt.accept('>');
            } else {
            ctxt.accept('>');
            // Repeat
            ctxt.skipWhiteSpace();
            fl646 = null;
            while(ctxt.lookAheadOpeningTag ("<Rule")) {
            fl646 = acceptor.lAccept_Rule(ctxt, "</Rule>");
            appendRules(fl646);
            ctxt.skipWhiteSpace();
            } // -- monomorphic Loop
            // EndRepeat
            ctxt.skipWhiteSpace();
            ctxt.acceptString ("</Rules>");
            } // If
            } // If
            // End enclosed
            ctxt.skipWhiteSpace();
            // Optional Enclosed
            if (ctxt.lookAheadOpeningTag("<Procedures")){
            ctxt.skipWhiteSpace();
            fl657 = true ;
            while (fl657) { // BeginLoop
            ctxt.skipWhiteSpace();
            if (ctxt.isAlNum()){
            ctxt.skipTill ('=');
            ctxt.advance();
            ctxt.skipWhiteSpace();
            quoteChar = ctxt.acceptQuote();
            ctxt.skipTill (quoteChar);
            ctxt.accept(quoteChar);
            ctxt.skipWhiteSpace();
            } else {
            fl657 = false ;
            } // If
            } // While
            if (ctxt.current() == '/'){
            ctxt.advance();
            ctxt.accept('>');
            } else {
            ctxt.accept('>');
            // Repeat
            ctxt.skipWhiteSpace();
            fl659 = null;
            while(ctxt.lookAheadOpeningTag ("<Procedure")) {
            fl659 = acceptor.lAccept_Procedure(ctxt, "</Procedure>");
            appendProcedures(fl659);
            ctxt.skipWhiteSpace();
            } // -- monomorphic Loop
            // EndRepeat
            ctxt.skipWhiteSpace();
            ctxt.acceptString ("</Procedures>");
            } // If
            } // If
            // End enclosed
            // Repeat
//.........这里部分代码省略.........

 /// <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 VariableModeEnumType lAcceptEnum_VariableModeEnumType(XmlBContext ctxt)
 {
     #pragma warning disable 0168, 0219
       int indicator=0;
     #pragma warning restore 0168, 0219
       VariableModeEnumType res = VariableModeEnumType.defaultVariableModeEnumType;
     switch (ctxt.current()) {
     case 'O':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("utgoing")){
     res = VariableModeEnumType.aOutgoing;
     } else {
     ctxt.moveBack(1);
     res = VariableModeEnumType.aInternal;
     } // If
     break;
     } // Case
     case 'I':
     {
     ctxt.advance();
     if (ctxt.lookAhead1('n')){
     switch (ctxt.current()) {
     case 't':
     {
     ctxt.advance();
     ctxt.acceptString ("ernal");
     res = VariableModeEnumType.aInternal;
     break;
     } // Case
     case 'c':
     {
     ctxt.advance();
     ctxt.acceptString ("oming");
     res = VariableModeEnumType.aIncoming;
     break;
     } // Case
     case 'O':
     {
     ctxt.advance();
     ctxt.accept2('u','t');
     res = VariableModeEnumType.aInOut;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2310)");
     break;
     } // Switch
     } else {
     ctxt.moveBack(1);
     res = VariableModeEnumType.aInternal;
     } // If
     break;
     } // Case
     case 'C':
     {
     ctxt.advance();
     if (ctxt.lookAheadString("onstant")){
     res = VariableModeEnumType.aConstant;
     } else {
     ctxt.moveBack(1);
     res = VariableModeEnumType.aInternal;
     } // If
     break;
     } // Case
     default:
     res = VariableModeEnumType.aInternal;
     break;
     } // Switch
     return res;
 }

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

 /// <summary>Utility function which parse an entity character 
 /// as defined in the XMLBooster configuration.</summary>
 /// <param name="ctxt">the context from which the data must be parsed</param>
 static char lAcceptPcDataChr(XmlBContext ctxt)
 {
     char c = (char)0;
     int indicator=0;
     switch (ctxt.current()) {
     case 'q':
     {
     ctxt.advance();
     ctxt.acceptString ("uot;");
     indicator = 2653;
     break;
     } // Case
     case 'n':
     {
     ctxt.advance();
     ctxt.acceptString ("bsp;");
     indicator = 2652;
     break;
     } // Case
     case 'l':
     {
     ctxt.advance();
     ctxt.accept2('t',';');
     indicator = 2650;
     break;
     } // Case
     case 'g':
     {
     ctxt.advance();
     ctxt.accept2('t',';');
     indicator = 2651;
     break;
     } // Case
     case 'a':
     {
     ctxt.advance();
     switch (ctxt.current()) {
     case 'p':
     {
     ctxt.advance();
     ctxt.accept3('o','s',';');
     indicator = 2654;
     break;
     } // Case
     case 'm':
     {
     ctxt.advance();
     ctxt.accept2('p',';');
     indicator = 2649;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2662)");
     break;
     } // Switch
     break;
     } // Case
     case '#':
     {
     ctxt.advance();
     ctxt.accept('x');
     indicator = 2655;
     break;
     } // Case
     default:
     ctxt.recoverableFail ("Other character expected (2664)");
     break;
     } // Switch
     switch (indicator) {
     case 2649: {
     c = XMLB_AMPERSAND;
     break;
     } // End of dispatch label
     case 2650: {
     c = XMLB_LESS;
     break;
     } // End of dispatch label
     case 2651: {
     c = XMLB_GREATER;
     break;
     } // End of dispatch label
     case 2652: {
     c = XMLB_NBSP;
     break;
     } // End of dispatch label
     case 2653: {
     c = XMLB_QUOT;
     break;
     } // End of dispatch label
     case 2654: {
     c = XMLB_APOS;
     break;
     } // End of dispatch label
     case 2655: {
     c = (char) ctxt.acceptHexa();
     ctxt.accept(';');
     break;
//.........这里部分代码省略.........