Examples of java.util.regex.MatchResult

java.util.regex.MatchResult
The result of a match operation.
This interface contains query methods used to determine the results of a match against a regular expression. The match boundaries, groups and group boundaries can be seen but not modified through a MatchResult. @author Michael McCloskey @version 1.6 11/17/05 @see Matcher @since 1.5

         }
      }
   }


   private boolean head_doctype(StringScanner source, Encoder encoder) {
      MatchResult m;
      if ( (m = source.scan(HEAD)) != null)
      {
         encoder.beginGroup(TokenType.head);
         encoder.textToken(m.group(), TokenType.head);
         encoder.endGroup(TokenType.head);
         return true;
      }
      else if ( (m = source.scan(DOCTYPE)) != null)
      {
         encoder.textToken(m.group(), TokenType.doctype);
         return true;
      }
      return false;
   }

View Full Code Here

      }
      return false;
   }


   private boolean delimiter(StringScanner source, Encoder encoder, Context context) {
      MatchResult m;
      int string_indent = 0;
      if ( source.check(STRING) == null && (m = source.scan(DOUBLE_QUOTE)) != null)
      {
         encoder.beginGroup(TokenType.string);
         encoder.textToken(m.group(), TokenType.delimiter);
         if ( (m = source.scan(COMMENT_ONELINE)) != null && !"".equals(m.group()))
         {
            encoder.textToken(m.group(), TokenType.content);
         }
         if ( (m = source.scan(DOUBLE_QUOTE)) != null)
         {
            encoder.textToken(m.group(), TokenType.delimiter);
         }
         encoder.endGroup(TokenType.string);
         return true;
      }
      else if ( (m = source.scan(LINE_CONTINUE)) != null)
      {
         encoder.beginGroup(TokenType.string);
         encoder.textToken(m.group(), TokenType.delimiter);
         string_indent = context.key_indent != null ? context.key_indent:source.column(source.index() - m.group().length())-1;
         if ( (m = source.scan(Pattern.compile("(?:\\n+ {" + (string_indent +1) + "}.*)+"))) != null)
         {
            encoder.textToken(m.group(), TokenType.content);
         }
         encoder.endGroup(TokenType.string);
         return true;
      }
      else if ( (m = source.scan(STRING_ENDLINE)) != null)
      {
         encoder.beginGroup(TokenType.string);
         encoder.textToken(m.group(), TokenType.content);
         string_indent = context.key_indent != null ? context.key_indent:source.column(source.index() - m.group().length())-1;
         if ( (m = source.scan(Pattern.compile("(?:\\n+ {" + (string_indent +1) + "}.*)+"))) != null)
         {
            encoder.textToken(m.group(), TokenType.content);
         }


         encoder.endGroup(TokenType.string);
         return true;
      }

View Full Code Here

      }
      return false;
   }


   private boolean value(StringScanner source, Encoder encoder, Context context) {
      MatchResult m;


      if ( (m = source.scan(OPERATOR)) != null)
      {
         if (context.state == State.colon && (m.group().equals(":") | m.group().equals("-")))
         {
            context.state = State.value;
         }
         else if (context.state == State.initial && m.group().equals("-"))
         {
            context.state = State.value;
         }
         encoder.textToken(m.group(), TokenType.operator);
         return true;
      }
      else if ( (m = source.scan(OPERATOR_BRACKETS)) != null)
      {
         encoder.textToken(m.group(), TokenType.operator);
         return true;
      }
      else if ( context.state == State.initial && (m = source.scan(KEY)) != null)
      {
         encoder.textToken(m.group(), TokenType.key);
         context.key_indent = source.column(source.index() - m.group().length()) - 1;
         context.state = State.colon;
         return true;
      }
      else if ( (m = source.scan(KEY_2)) != null)
      {
         encoder.beginGroup(TokenType.key);
         String match = m.group();
         encoder.textToken(match.substring(0, 1), TokenType.delimiter);
         if (match.length() > 2)
         {
            encoder.textToken(match.substring(1, match.length()-1), TokenType.content);
         }
         encoder.textToken(match.substring(match.length()-1), TokenType.delimiter);
         encoder.endGroup(TokenType.key);
         context.key_indent = source.column(source.index() - match.length()) - 1;
         context.state = State.colon;
         return true;
      }
      else if ( (m = source.scan(TYPE_EXP)) != null)
      {
         encoder.textToken(m.group(1), TokenType.type);
         if (m.group(2) != null)
         {
            encoder.textToken(":", TokenType.operator);
            encoder.textToken(m.group(3), TokenType.class_);
         }
         return true;
      }
      else if ( (m = source.scan(VARIABLE)) != null)
      {
         encoder.textToken(m.group(), TokenType.variable);
         return true;
      }
      else if ( (m = source.scan(GLOBAL_VARIABLE)) != null)
      {
         encoder.textToken(m.group(), TokenType.global_variable);
         return true;
      }
      else if ( (m = source.scan(CLASS_VARIABLE)) != null)
      {
         encoder.textToken(m.group(), TokenType.class_variable);
         return true;
      }
      else if ( (m = source.scan(OCTAL)) != null)
      {
         encoder.textToken(m.group(), TokenType.octal);
         return true;
      }
      else if ( (m = source.scan(OCTAL_2)) != null)
      {
         encoder.textToken(m.group(), TokenType.octal);
         return true;
      }
      else if ( (m = source.scan(SYMBOL)) != null)
      {
         encoder.textToken(m.group(), TokenType.symbol);
         return true;
      }
      else if ( (m = source.scan(ERROR)) != null)
      {
         encoder.textToken(m.group(), TokenType.error);
         return true;
      }
      else if ( (m = source.scan(ERROR_2)) != null)
      {
         encoder.textToken(m.group(), TokenType.error);
         return true;
      }
      return false;
   }

View Full Code Here

   {
      State state = State.initial;


      while (source.hasMore())
      {
         MatchResult m = null;


         switch (state)
         {


         case initial:
            if ((m = source.scan(SPACE)) != null)
            {
               encoder.textToken(m.group(), TokenType.space);
            }
            else if ((m = source.scan(DOUBLE_QUOTE)) != null)
            {
               state = source.check(KEY) != null ? State.key : State.string;
               encoder.beginGroup(TokenType.valueOf(state.name()));
               encoder.textToken(m.group(), TokenType.delimiter);
            }
            else if ((m = source.scan(OPERATOR)) != null)
            {
               encoder.textToken(m.group(), TokenType.operator);
            }
            else if ((m = source.scan(BOOLEAN)) != null)
            {
               encoder.textToken(m.group(), TokenType.value);
            }
            else if ((m = source.scan(NUMBER)) != null)
            {
               String match = m.group();
               if ((m = source.scan(FLOAT)) != null)
               {
                  match = match + m.group();
                  encoder.textToken(match, TokenType.float_);
               }
               else
               {
                  encoder.textToken(match, TokenType.integer);
               }
            }
            else
            {
               encoder.textToken(source.next(), TokenType.error);
            }
            break;
         case key:
         case string:


            if ((m = source.scan(CONTENT)) != null)
            {
               encoder.textToken(m.group(), TokenType.content);
            }
            else if ((m = source.scan(DOUBLE_QUOTE)) != null)
            {
               encoder.textToken(m.group(), TokenType.delimiter);
               encoder.endGroup(TokenType.valueOf(state.name()));
               state = State.initial;
            }
            else if ((m = source.scan(CHAR)) != null)
            {
               encoder.textToken(m.group(), TokenType.char_);
            }
            else if ((m = source.scan(CONTENT_2)) != null)
            {
               encoder.textToken(m.group(), TokenType.content);
            }
            else if ((m = source.scan(END)) != null)
            {
               encoder.endGroup(TokenType.valueOf(state.name()));
               if (!m.group().isEmpty())
               {
                  encoder.textToken(m.group(), TokenType.error);
               }
               state = State.initial;
            }
            else
            {

View Full Code Here

      boolean key_expected = false;
      boolean function_expected = false;


      while (source.hasMore())
      {
         MatchResult m = null;


         switch (state)
         {
         case initial:


            if ((m = source.scan(SPACE)) != null)
            {
               if (!value_expected && m.group().indexOf("\n") != -1)
               {
                  value_expected = true;
               }
               encoder.textToken(m.group(), TokenType.space);
            }
            else if ((m = source.scan(COMMENT)) != null)
            {
               value_expected = true;
               encoder.textToken(m.group(), TokenType.comment);
               if (m.group(1) != null)
               {
                  state = State.open_multi_line_comment;
               }
            }
            else if ((m = source.check(NUMBER)) != null)
            {
               key_expected = value_expected = false;
               if ((m = source.scan(HEX)) != null)
               {
                  encoder.textToken(m.group(), TokenType.hex);
               }
               else if ((m = source.scan(OCTAL)) != null)
               {
                  encoder.textToken(m.group(), TokenType.octal);
               }
               else if ((m = source.scan(FLOAT)) != null)
               {
                  encoder.textToken(m.group(), TokenType.float_);
               }
               else if ((m = source.scan(INTEGER)) != null)
               {
                  encoder.textToken(m.group(), TokenType.integer);
               }
            }
            else if (value_expected && (m = source.scan(HTML)) != null)
            {
               Syntax.Builder.create()
                        .scannerType(HTMLScanner.TYPE.getName())
                        .encoder(encoder)
                        .execute(m.group());
               value_expected = true;
               continue;
            }
            else if ((m = source.scan(OPERATOR)) != null)
            {
               value_expected = true;
               String last_operator = m.group().substring(m.group().length() - 1);
               key_expected = last_operator.equals("{") || last_operator.equals(",");
               function_expected = false;
               encoder.textToken(m.group(), TokenType.operator);
            }
            else if ((m = source.scan(OPERATOR_END)) != null)
            {
               function_expected = key_expected = value_expected = false;
               encoder.textToken(m.group(), TokenType.operator);
            }
            else if ((m = source.scan(IDENT)) != null)
            {
               TokenType kind = IDENT_KIND.lookup(m.group());
               value_expected = (kind == TokenType.keyword) && KEYWORDS_EXPECTING_VALUE.lookup(m.group());
               if (TokenType.ident == kind)
               {
                  if (m.group().indexOf("$") != -1)
                  {
                     kind = TokenType.predefined;
                  }
                  else if (function_expected)
                  {
                     kind = TokenType.function;
                  }
                  else if (source.check(FUNCTION) != null)
                  {
                     kind = TokenType.function;
                  }
                  else if (key_expected && source.check(KEY) != null)
                  {
                     kind = TokenType.key;
                  }
               }
               function_expected = (kind == TokenType.keyword && m.group().equals("function"));
               key_expected = false;
               encoder.textToken(m.group(), kind);
            }
            else if ((m = source.scan(ARRAY_KEY)) != null)
            {
               if (key_expected && source.check(KEY_CHECK_PATTERN.get(m.group())) != null)
               {
                  state = State.key;
               }
               else
               {
                  state = State.string;
               }
               encoder.beginGroup(TokenType.valueOf(state.name()));
               string_delimiter = m.group();
               encoder.textToken(m.group(), TokenType.delimiter);
            }
            else if (value_expected && (m = source.scan(REGEXP)) != null)
            {
               encoder.beginGroup(TokenType.regexp);
               state = State.regexp;
               string_delimiter = "/";
               encoder.textToken(m.group(), TokenType.delimiter);
            }
            else if ((m = source.scan(REGEXP)) != null)
            {
               value_expected = true;
               key_expected = false;
               encoder.textToken(m.group(), TokenType.operator);
            }
            else
            {
               encoder.textToken(source.next(), TokenType.error);
            }
            break;


         case string:
         case regexp:
         case key:


            if ((m = source.scan(STRING_CONTENT_PATTERN.get(string_delimiter))) != null)
            {
               encoder.textToken(m.group(), TokenType.content);
            }
            else if ((m = source.scan(DELIMITER)) != null)
            {
               encoder.textToken(m.group(), TokenType.delimiter);
               if (State.regexp == state)
               {
                  MatchResult modifiers;
                  if ((modifiers = source.scan(MODIFIER)) != null)
                  {
                     encoder.textToken(modifiers.group(), TokenType.modifier);
                  }
               }
               encoder.endGroup(TokenType.valueOf(state.name()));
               string_delimiter = null;
               key_expected = value_expected = false;

View Full Code Here

      String stringType = null;
      boolean nameExpected = false;


      while (source.hasMore())
      {
         MatchResult m = null;


         switch (state)
         {
         case initial:


            if ((m = source.scan(SPACE)) != null)
            {
               encoder.textToken(m.group(), TokenType.space);
            }
            else if ((m = source.scan(COMMENT)) != null)
            {
               encoder.textToken(m.group(), TokenType.comment);
            }
            else if ((m = source.scan(COMMENT_DIRECTIVE)) != null)
            {
               encoder.textToken(m.group(), m.group(1) != null ? TokenType.directive:TokenType.comment);
            }
            else if ((m = source.scan(OPERATOR)) != null)
            {
               if (m.group().equals(".") && source.check(LETTER) != null)
               {
                  nameExpected = true;
               }
               encoder.textToken(m.group(), TokenType.operator);
            }
            else if ((m = source.scan(STRING)) != null)
            {
               String prefix = m.group(1);
               stringType = m.group(2);
               encoder.beginGroup(TokenType.string);
               if (prefix != null)
               {
                  encoder.textToken(prefix, TokenType.modifier);
               }
               state = State.string;
               encoder.textToken(stringType, TokenType.delimiter);
            }
            else if ((m = source.scan(IDENT)) != null)
            {
               encoder.textToken(m.group(), nameExpected ? TokenType.ident:(m.group().startsWith("@") ? TokenType.variable:IDENT_KIND.lookup(m.group())));
               nameExpected = false;
            }
            else if ((m = source.scan(HEX)) != null)
            {
               encoder.textToken(m.group(), TokenType.hex);
            }
            else if ((m = source.scan(OCTAL)) != null)
            {
               encoder.textToken(m.group(), TokenType.octal);
            }
            else if ((m = source.scan(INTEGER)) != null)
            {
               encoder.textToken(m.group(), TokenType.integer);
            }
            else if ((m = source.scan(FLOAT)) != null)
            {
               encoder.textToken(m.group(), TokenType.float_);
            }
            else if ((m = source.scan(PREDEFINED_CONSTANT)) != null)
            {
               encoder.textToken(m.group(), TokenType.predefined_constant);
            }
            else {
               encoder.textToken(source.next(), TokenType.error);
            }
            break;


         case string:
            if ((m = source.scan(STRING_CONTENT_PATTERN.get(stringType))) != null)
            {
               encoder.textToken(m.group(), TokenType.content);
            }
            else if ((m = source.scan(DELIMITER)) != null)
            {
               if (m.group().equals(stringType))
               {
                  if (source.peek(1).equals(stringType))
                  {
                     encoder.textToken(m.group() + source.next(), TokenType.content);
                  }
                  else
                  {
                     encoder.textToken(m.group(), TokenType.delimiter);
                     encoder.endGroup(TokenType.string);
                     state = State.initial;
                     stringType = null;
                  }
               }
               else
               {
                  encoder.textToken(m.group(), TokenType.content);
               }
            }
            else if ((m = source.scan(CHAR)) != null)
            {
               encoder.textToken(m.group(), TokenType.char_);
            }
            else if ((m = source.scan(CONTENT)) != null)
            {
               encoder.textToken(m.group(), TokenType.content);
            }
            else if ((m = source.scan(STRING_END)) != null)
            {
               if (m.group().length() != 0)
               {
                  encoder.textToken(m.group(), TokenType.error);
               }
               encoder.endGroup(TokenType.string);
               state = State.initial;
            }
            else

View Full Code Here

   public MatchResult scan(Pattern pattern)
   {
      Matcher m = pattern.matcher(sequence);
      if (m.lookingAt())
      {
         MatchResult result = new StaticMatchResult(sequence, m);
         sequence.advance(m.end());
         return result;
      }
      return null;
   }

View Full Code Here

   public MatchResult scanUntil(Pattern pattern)
   {
      Matcher m = pattern.matcher(sequence);
      if (m.find())
      {
         MatchResult result = new UntilStaticMatchResult(sequence, m);
         sequence.advance(m.end());
         return result;
      }
      return null;
   }

View Full Code Here

      boolean value_expected = true;
      TokenType kind = null;


      while (source.hasMore())
      {
         MatchResult m = null;


         switch (state)
         {
         case initial:


            if ((m = source.scan(SPACE)) != null)
            {
               encoder.textToken(m.group(), TokenType.space);
               if(m.group().indexOf("\n") != -1)
               {
                  import_clause = after_def = false;
                  if(!value_expected)
                  {
                     value_expected = true;
                  }
               }
               continue;
            }
            else if ((m = source.scan(COMMENT)) != null)
            {
               value_expected = true;
               after_def = false;
               encoder.textToken(m.group(), TokenType.comment);
            }
            else if ((m = source.scan(DOCTYPE)) != null)
            {
               encoder.textToken(m.group(), TokenType.doctype);
            }
            else if (import_clause && (m = source.scan(INCLUDE)) != null)
            {
               after_def = value_expected = false;
               encoder.textToken(m.group(), TokenType.include);
            }
            else if ((m = source.scan(IDENT)) != null)
            {
               kind = IDENT_KIND.lookup(m.group());
               value_expected = (kind == TokenType.keyword) && KEYWORDS_EXPECTING_VALUE.lookup(m.group());
               if (".".equals(last_token))
               {
                  kind = TokenType.ident;
               }
               else if (class_name_follows)
               {
                  kind = TokenType.class_;
                  class_name_follows = false;
               }
               else if (after_def && source.check(AFTER_DEF) != null)
               {
                  kind = TokenType.method;
                  after_def = false;
               }
               else if (kind == TokenType.ident && !"?".equals(last_token) && source.check(":") != null)
               {
                  kind = TokenType.key;
               }
               else
               {
                  if (m.group().equals("class") || (import_clause && m.group().equals("as")))
                  {
                     class_name_follows = true;
                  }
                  import_clause = (m.group().equals("import"));
                  if(m.group().equals("def"))
                  {
                     after_def = true;
                  }
               }
               encoder.textToken(m.group(), kind);
            }
            else if ((m = source.scan(SEMI_COLON)) != null)
            {
               import_clause = after_def = false;
               value_expected = true;
               encoder.textToken(m.group(), TokenType.operator);
            }
            else if ((m = source.scan(START_BRACKET)) != null)
            {
               class_name_follows = after_def = false;
               value_expected = true;
               encoder.textToken(m.group(), TokenType.operator);
               if (!inlineBlockStack.isEmpty())
               {
                  inlineBlockParenDepth += 1;
               }
            }
            else if ((m = source.scan(OPERATOR)) != null)
            {
               value_expected = true;
               //value_expected = :regexp if match == '~';
               after_def = false;


               encoder.textToken(m.group(), TokenType.operator);
            }
            else if ((m = source.scan(END_BRACKET)) != null)
            {
               value_expected = after_def = false;
               if (!inlineBlockStack.isEmpty() && m.group().equals("}"))
               {
                  inlineBlockParenDepth -= 1;
                  if (inlineBlockParenDepth == 0 ) // # closing brace of inline block reached
                  {
                     encoder.textToken(m.group(),  TokenType.inline_delimiter);
                     encoder.endGroup(TokenType.inline);
                     Object[] inlineBlock = inlineBlockStack.pop();
                     state = (State)inlineBlock[0];
                     stringDelimiter = (String)inlineBlock[1];
                     inlineBlockParenDepth = (int)inlineBlock[2];
                     continue;
                  }
               }
               encoder.textToken(m.group(), TokenType.operator);
            }
            else if (source.check(NUMBER) != null)
            {
               after_def = value_expected = false;
               if ((m = source.scan(HEX)) != null)
               {
                  encoder.textToken(m.group(), TokenType.hex);
               }
               else if ((m = source.scan(OCTAL)) != null)
               {
                  encoder.textToken(m.group(), TokenType.octal);
               }
               else if ((m = source.scan(FLOAT)) != null)
               {
                  encoder.textToken(m.group(), TokenType.float_);
               }
               else if ((m = source.scan(INTEGER)) != null)
               {
                  encoder.textToken(m.group(), TokenType.integer);
               }
            }
            else if ((m = source.scan(MULTI_LINE_DELIMITER)) != null)
            {
               after_def = value_expected = false;
               state = State.multiline_string;
               encoder.beginGroup(TokenType.string);
               stringDelimiter = m.group();
               encoder.textToken(m.group(), TokenType.delimiter);
            }
            else if ((m = source.scan(STRING_DELIMITER)) != null)
            {
               after_def = value_expected = false;
               state = m.group().equals("/") ? State.regexp :State.string;
               encoder.beginGroup(TokenType.valueOf(state.name()));
               stringDelimiter = m.group();
               encoder.textToken(m.group(), TokenType.delimiter);
            }
            else if (value_expected && (m = source.scan(START_REGEXP)) != null)
            {
               after_def = value_expected = false;
               encoder.beginGroup(TokenType.regexp);
               state = State.regexp;
               stringDelimiter = "/";
               encoder.textToken(m.group(), TokenType.delimiter);
            }
            else if ((m = source.scan(ANNOTATION)) != null)
            {
               after_def = value_expected = false;
               encoder.textToken(m.group(), TokenType.annotation);
            }
            else if ((m = source.scan(END_OPERATOR)) != null)
            {
               after_def = false;
               value_expected = true;
               encoder.textToken(m.group(), TokenType.operator);
            }
            else
            {
               encoder.textToken(source.next(), TokenType.error);
            }
            break;


         case string:
         case regexp:
         case multiline_string:


            if ((m = source.scan(STRING_CONTENT_PATTERN.get(stringDelimiter))) != null)
            {
               encoder.textToken(m.group(), TokenType.content);
            }
            else if ((m = source.scan(state == State.multiline_string ? "'''|\"\"\"":"[\"'\\/]")) != null)
            {
               encoder.textToken(m.group(), TokenType.delimiter);
               if (state == State.regexp)
               {
                  MatchResult modifiers = source.scan("[ix]+");
                  if (modifiers != null && !modifiers.group().equals(""))
                  {
                     encoder.textToken(modifiers.group(), TokenType.modifier);
                  }
               }
               if (state == State.multiline_string)
               {
                  state = State.string;

View Full Code Here

    if (scanner.hasNext(REG_EX_STATUS_LINE)) {
      scanner.next(REG_EX_STATUS_LINE);
      currentLineNumber++;
      final String statusCode;
      final String statusInfo;
      MatchResult result = scanner.match();
      if (result.groupCount() == 2) {
        statusCode = result.group(1);
        statusInfo = result.group(2);
      } else {
        currentLineNumber++;
        throw new BatchException(BatchException.INVALID_STATUS_LINE.addContent(scanner.next()).addContent(
            currentLineNumber));
      }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.regex.MatchResult

ch.inftec.ju.util.RegexUtil

classes.test.ScannerTest

com.alibaba.citrus.service.requestcontext.rewrite.impl.RewriteRequestContextImpl

com.alibaba.citrus.service.requestcontext.rewrite.impl.RewriteRule

com.alibaba.citrus.service.requestcontext.rewrite.impl.RewriteSubstitution

com.alibaba.citrus.util.regex.MatchResultSubstitution

com.dmurph.tracking.JGoogleAnalyticsTracker

com.ericsson.ssa.sip.dns.EnumUtil

com.google.common.testing.junit3.JUnitAssertsTest

com.google.common.testing.junit4.JUnitAssertsTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.