Ticket #8476: regex.patch

File regex.patch, 5.1 KB (added by Alexander Kornienko <alexfh@…>, 10 years ago)

  • boost/regex/v4/basic_regex_creator.hpp

     
    738738      case syntax_element_long_set_rep:
    739739         // set the state_id of this repeat:
    740740         static_cast<re_repeat*>(state)->state_id = m_repeater_id++;
    741          // fall through:
     741         BOOST_FALLTHROUGH;
    742742      case syntax_element_alt:
    743743         std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map));
    744744         static_cast<re_alt*>(state)->can_be_null = 0;
    745          // fall through:
     745         BOOST_FALLTHROUGH;
    746746      case syntax_element_jump:
    747747         static_cast<re_jump*>(state)->alt.p = getaddress(static_cast<re_jump*>(state)->alt.i, state);
    748          // fall through again:
     748         BOOST_FALLTHROUGH;
    749749      default:
    750750         if(state->next.i)
    751751            state->next.p = getaddress(state->next.i, state);
    … …  
    877877               }
    878878            }
    879879         }
     880         break;
    880881      default:
    881882         break;
    882883      }
    … …  
    941942               e.raise();
    942943            }
    943944         }
    944          // fall through:
     945         BOOST_FALLTHROUGH;
    945946      default:
    946947         state = state->next.p;
    947948      }
    … …  
    11531154               break;
    11541155            }
    11551156            m_recursion_checks[recursion_sub] = true;
    1156             // fall through, can't handle nested recursion here...
     1157            // can't handle nested recursion here...
     1158            BOOST_FALLTHROUGH;
    11571159         }
    11581160      case syntax_element_backref:
    11591161         // can be null, and any character can match:
    11601162         if(pnull)
    11611163            *pnull |= mask;
    1162          // fall through:
     1164         BOOST_FALLTHROUGH;
    11631165      case syntax_element_wild:
    11641166      {
    11651167         // can't be null, any character can match:
    … …  
    13591361            state = state->next.p->next.p;
    13601362            break;
    13611363         }
    1362          // otherwise fall through:
     1364         BOOST_FALLTHROUGH;
    13631365      default:
    13641366         state = state->next.p;
    13651367      }
    … …  
    14561458         if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT)
    14571459            m_bad_repeats |= (one << state_id);
    14581460      }
     1461      break;
    14591462   default:
    14601463      break;
    14611464   }
    … …  
    15371540      case syntax_element_long_set_rep:
    15381541         if(this->m_has_backrefs == 0)
    15391542            static_cast<re_repeat*>(state)->leading = true;
    1540          // fall through:
     1543         BOOST_FALLTHROUGH;
    15411544      default:
    15421545         return;
    15431546      }

  • boost/regex/v4/basic_regex_parser.hpp

     
    369369         while((m_position != m_end) && !is_separator(*m_position++)){}
    370370         return true;
    371371      }
    372       // Otherwise fall through:
     372      BOOST_FALLTHROUGH;
    373373   default:
    374374      result = parse_literal();
    375375      break;
    … …  
    623623         {
    624624         case 'w':
    625625            negate = false;
    626             // fall through:
     626            BOOST_FALLTHROUGH;
    627627         case 'W':
    628628            {
    629629            basic_char_set<charT, traits> char_set;
    … …  
    640640            }
    641641         case 's':
    642642            negate = false;
    643             // fall through:
     643            BOOST_FALLTHROUGH;
    644644         case 'S':
    645645            return add_emacs_code(negate);
    646646         case 'c':
    … …  
    672672   {
    673673   case regex_constants::escape_type_not_class:
    674674      negate = true;
    675       // fall through:
     675      BOOST_FALLTHROUGH;
    676676   case regex_constants::escape_type_class:
    677677      {
    678678escape_type_class_jump:
    … …  
    742742      break;
    743743   case regex_constants::escape_type_not_property:
    744744      negate = true;
    745       // fall through:
     745      BOOST_FALLTHROUGH;
    746746   case regex_constants::escape_type_property:
    747747      {
    748748         ++m_position;
    … …  
    901901   case regex_constants::escape_type_control_v:
    902902      if(0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex)))
    903903         goto escape_type_class_jump;
    904       // fallthrough:
     904      BOOST_FALLTHROUGH;
    905905   default:
    906906      this->append_literal(unescape_character());
    907907      break;
    … …  
    19591959   {
    19601960   case regex_constants::syntax_or:
    19611961      m_mark_reset = m_mark_count;
    1962       // fall through:
     1962      BOOST_FALLTHROUGH;
    19631963   case regex_constants::syntax_colon:
    19641964      //
    19651965      // a non-capturing mark:

  • boost/regex/v4/regex_format.hpp

     
    283283            format_perl();
    284284            break;
    285285         }
    286          // fall through, not a special character:
     286         // not a special character:
     287         BOOST_FALLTHROUGH;
    287288      default:
    288289         put(*m_position);
    289290         ++m_position;
    … …  
    354355   case '{':
    355356      have_brace = true;
    356357      ++m_position;
    357       // fall through....
     358      BOOST_FALLTHROUGH;
    358359   default:
    359360      // see if we have a number:
    360361      {