/*
* Copyright 2003-2007 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
/* This file has been extensively modified from the original Sun implementation
* to provide for compile time checking of Format Strings.
*
* These modifications were performed by Bill Pugh, this code is free software.
*
*/
package edu.umd.cs.findbugs.formatStringChecker;
import java.util.ArrayList;
import java.util.FormatFlagsConversionMismatchException;
import java.util.IllegalFormatException;
import java.util.List;
import java.util.UnknownFormatConversionException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public final class Formatter {
public static void check(String format, String... args)
throws ExtraFormatArgumentsException,
IllegalFormatConversionException, IllegalFormatException,
FormatFlagsConversionMismatchException,
MissingFormatArgumentException, FormatterNumberFormatException {
// index of last argument referenced
int last = -1;
// last ordinary index
int lasto = -1;
// last index used
int maxIndex = -1;
for (FormatSpecifier fs : parse(format)) {
int index = fs.index();
switch (index) {
case -2:
// ignore it
break;
case -1: // relative index
if (last < 0 || last > args.length - 1)
throw new MissingFormatArgumentException(last,
fs.toString());
fs.print(args[last], last);
break;
case 0: // ordinary index
lasto++;
last = lasto;
if (lasto > args.length - 1)
throw new MissingFormatArgumentException(lasto,
fs.toString());
maxIndex = Math.max(maxIndex, lasto);
fs.print(args[lasto], lasto);
break;
default: // explicit index
last = index - 1;
if (last > args.length - 1)
throw new MissingFormatArgumentException(last,
fs.toString());
maxIndex = Math.max(maxIndex, last);
fs.print(args[last], last);
break;
}
}
if (maxIndex < args.length - 1) {
throw new ExtraFormatArgumentsException(args.length, maxIndex + 1);
}
}
// %[argument_index$][flags][width][.precision][t]conversion
private static final String formatSpecifier = "%(\\d+\\$)?([-#+ 0,(\\<]*)?(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])";
private static Pattern fsPattern = Pattern.compile(formatSpecifier);
// Look for format specifiers in the format string.
private static List<FormatSpecifier> parse(String s)
throws FormatFlagsConversionMismatchException,
FormatterNumberFormatException {
ArrayList<FormatSpecifier> al = new ArrayList<FormatSpecifier>();
Matcher m = fsPattern.matcher(s);
int i = 0;
while (i < s.length()) {
if (m.find(i)) {
// Anything between the start of the string and the beginning
// of the format specifier is either fixed text or contains
// an invalid format string.
if (m.start() != i) {
// Make sure we didn't miss any invalid format specifiers
checkText(s.substring(i, m.start()));
}
// Expect 6 groups in regular expression
String[] sa = new String[6];
for (int j = 0; j < m.groupCount(); j++) {
sa[j] = m.group(j + 1);
}
al.add(new FormatSpecifier(m.group(0), sa));
i = m.end();
} else {
// No more valid format specifiers. Check for possible invalid
// format specifiers.
checkText(s.substring(i));
// The rest of the string is fixed text
break;
}
}
return al;
}
private static void checkText(String s) {
int idx;
// If there are any '%' in the given string, we got a bad format
// specifier.
if ((idx = s.indexOf('%')) != -1) {
char c = (idx > s.length() - 2 ? '%' : s.charAt(idx + 1));
throw new UnknownFormatConversionException(String.valueOf(c));
}
}
}