Java Code Examples for com.sun.tools.javac.util.Log#warning()

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is not a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(boolean allowModules, String s, Processor p, Log log) {
    String module;
    String pkg;
    int slash = s.indexOf('/');
    if (slash == (-1)) {
        if (s.equals("*")) {
            return MatchingUtils.validImportStringToPattern(s);
        }
        module = allowModules ? ".*/" : "";
        pkg = s;
    } else {
        module = Pattern.quote(s.substring(0, slash + 1));
        pkg = s.substring(slash + 1);
    }
    if (MatchingUtils.isValidImportString(pkg)) {
        return Pattern.compile(module + MatchingUtils.validImportStringToPatternString(pkg));
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is not a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(boolean allowModules, String s, Processor p, Log log) {
    String module;
    String pkg;
    int slash = s.indexOf('/');
    if (slash == (-1)) {
        if (s.equals("*")) {
            return MatchingUtils.validImportStringToPattern(s);
        }
        module = allowModules ? ".*/" : "";
        pkg = s;
    } else {
        module = Pattern.quote(s.substring(0, slash + 1));
        pkg = s.substring(slash + 1);
    }
    if (MatchingUtils.isValidImportString(pkg)) {
        return Pattern.compile(module + MatchingUtils.validImportStringToPatternString(pkg));
    } else {
        log.warning(Warnings.ProcMalformedSupportedString(s, p.getClass().getName()));
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

@Override
public <T> void report( Log issueLogger, Diagnostic<? extends T> diagnostic )
{
  // Adapted from JavacMessager.printMessage.  Following same basic routine regarding use of Log

  JavaFileObject oldSource = issueLogger.useSource( (JavaFileObject)diagnostic.getSource() );
  boolean oldMultipleErrors = issueLogger.multipleErrors;
  issueLogger.multipleErrors = true;
  try
  {
    switch( diagnostic.getKind() )
    {
      case ERROR:
        issueLogger.error( new IssueReporter.Position( diagnostic ), "proc.messager", diagnostic.getMessage( Locale.getDefault() ) );
        break;
      case WARNING:
        issueLogger.warning( new IssueReporter.Position( diagnostic ), "proc.messager", diagnostic.getMessage( Locale.getDefault() ) );
        break;
      case MANDATORY_WARNING:
        issueLogger.mandatoryWarning( new IssueReporter.Position( diagnostic ), "proc.messager", diagnostic.getMessage( Locale.getDefault() ) );
        break;
      case NOTE:
      case OTHER:
        issueLogger.note( new IssueReporter.Position( diagnostic ), "proc.messager", diagnostic.getMessage( Locale.getDefault() ) );
        break;
    }
  }
  finally
  {
    issueLogger.useSource( oldSource );
    issueLogger.multipleErrors = oldMultipleErrors;
  }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(String s, Processor p, Log log) {
    if (isValidImportString(s)) {
        return validImportStringToPattern(s);
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(String s, Processor p, Log log) {
    if (isValidImportString(s)) {
        return validImportStringToPattern(s);
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning(Warnings.ProcProcessorIncompatibleSourceVersion(procSourceVersion,
                                                                    processor.getClass().getName(),
                                                                    source.name));
    }
}
 

/** Source file positions in CRT are integers in the format:
*  {@literal line-number << LINESHIFT + column-number }
*/
private int encodePosition(int pos, Position.LineMap lineMap, Log log) {
    int line = lineMap.getLineNumber(pos);
    int col = lineMap.getColumnNumber(pos);
    int new_pos = Position.encodePosition(line, col);
    if (crtDebug) {
        System.out.println(", line = " + line + ", column = " + col +
                           ", new_pos = " + new_pos);
    }
    if (new_pos == Position.NOPOS)
        log.warning(pos, Warnings.PositionOverflow(line));

   return new_pos;
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(String s, Processor p, Log log) {
    if (isValidImportString(s)) {
        return validImportStringToPattern(s);
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(String s, Processor p, Log log) {
    if (isValidImportString(s)) {
        return validImportStringToPattern(s);
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(String s, Processor p, Log log) {
    if (isValidImportString(s)) {
        return validImportStringToPattern(s);
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(String s, Processor p, Log log) {
    if (isValidImportString(s)) {
        return validImportStringToPattern(s);
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}
 

/**
 * Checks whether or not a processor's source version is
 * compatible with the compilation source version.  The
 * processor's source version needs to be greater than or
 * equal to the source version of the compile.
 */
private void checkSourceVersionCompatibility(Source source, Log log) {
    SourceVersion procSourceVersion = processor.getSupportedSourceVersion();

    if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 )  {
        log.warning("proc.processor.incompatible.source.version",
                    procSourceVersion,
                    processor.getClass().getName(),
                    source.name);
    }
}
 

/**
 * Convert import-style string for supported annotations into a
 * regex matching that string.  If the string is a valid
 * import-style string, return a regex that won't match anything.
 */
private static Pattern importStringToPattern(String s, Processor p, Log log) {
    if (isValidImportString(s)) {
        return validImportStringToPattern(s);
    } else {
        log.warning("proc.malformed.supported.string", s, p.getClass().getName());
        return noMatches; // won't match any valid identifier
    }
}