/** * Instantiate an object given a class name. Check that the <code>className</code> is a subclass * of <code>superClass</code>. If that test fails or the object could not be instantiated, then * <code>defaultValue</code> is returned. * * @param className The fully qualified class name of the object to instantiate. * @param superClass The class to which the new object should belong. * @param defaultValue The object to return in case of non-fulfillment */ public static Object instantiateByClassName( String className, Class superClass, Object defaultValue) { if (className != null) { try { Class classObj = Loader.loadClass(className); if (!superClass.isAssignableFrom(classObj)) { LogLog.error( "A \"" + className + "\" object is not assignable to a \"" + superClass.getName() + "\" variable."); LogLog.error("The class \"" + superClass.getName() + "\" was loaded by "); LogLog.error("[" + superClass.getClassLoader() + "] whereas object of type "); LogLog.error( "\"" + classObj.getName() + "\" was loaded by [" + classObj.getClassLoader() + "]."); return defaultValue; } return classObj.newInstance(); } catch (Exception e) { LogLog.error("Could not instantiate class [" + className + "].", e); } } return defaultValue; }
public static long toFileSize(String value, long dEfault) { if (value == null) return dEfault; String s = value.trim().toUpperCase(); long multiplier = 1; int index; if ((index = s.indexOf("KB")) != -1) { multiplier = 1024; s = s.substring(0, index); } else if ((index = s.indexOf("MB")) != -1) { multiplier = 1024 * 1024; s = s.substring(0, index); } else if ((index = s.indexOf("GB")) != -1) { multiplier = 1024 * 1024 * 1024; s = s.substring(0, index); } if (s != null) { try { return Long.valueOf(s).longValue() * multiplier; } catch (NumberFormatException e) { LogLog.error("[" + s + "] is not in proper int form."); LogLog.error("[" + value + "] not in expected format.", e); } } return dEfault; }
/** The option is expected to be in decimal and positive. In case of error, zero is returned. */ protected int extractPrecisionOption() { String opt = extractOption(); int r = 0; if (opt != null) { try { r = Integer.parseInt(opt); if (r <= 0) { LogLog.error("Precision option (" + opt + ") isn't a positive integer."); r = 0; } } catch (NumberFormatException e) { LogLog.error("Category option \"" + opt + "\" not a decimal integer.", e); } } return r; }
/** * Very similar to <code>System.getProperty</code> except that the {@link SecurityException} is * hidden. * * @param key The key to search for. * @param def The default value to return. * @return the string value of the system property, or the default value if there is no property * with that key. * @since 1.1 */ public static String getSystemproperty(String key, String def) { try { return System.getProperty(key, def); } catch (Throwable e) { // MS-Java throws com.ms.security.SecurityExceptionEx LogLog.debug("Was not allowed to read system property \"" + key + "\"."); return def; } }
public SyslogWriter(String syslogHost) { this.syslogHost = syslogHost; try { this.address = InetAddress.getByName(syslogHost); } catch (UnknownHostException e) { LogLog.error("Could not find " + syslogHost + ". All logging will FAIL.", e); } try { this.ds = new DatagramSocket(); } catch (SocketException e) { e.printStackTrace(); LogLog.error( "Could not instantiate DatagramSocket to " + syslogHost + ". All logging will FAIL.", e); } }
/** * Converts a standard or custom priority level to a Level object. * * <p>If <code>value</code> is of form "level#classname", then the specified class' toLevel method * is called to process the specified level string; if no '#' character is present, then the * default {@link org.apache.log4j.Level} class is used to process the level value. * * <p>As a special case, if the <code>value</code> parameter is equal to the string "NULL", then * the value <code>null</code> will be returned. * * <p>If any error occurs while converting the value to a level, the <code>defaultValue</code> * parameter, which may be <code>null</code>, is returned. * * <p>Case of <code>value</code> is insignificant for the level level, but is significant for the * class name part, if present. * * @since 1.1 */ public static Level toLevel(String value, Level defaultValue) { if (value == null) return defaultValue; value = value.trim(); int hashIndex = value.indexOf('#'); if (hashIndex == -1) { if ("NULL".equalsIgnoreCase(value)) { return null; } else { // no class name specified : use standard Level class return (Level) Level.toLevel(value, defaultValue); } } Level result = defaultValue; String clazz = value.substring(hashIndex + 1); String levelName = value.substring(0, hashIndex); // This is degenerate case but you never know. if ("NULL".equalsIgnoreCase(levelName)) { return null; } LogLog.debug("toLevel" + ":class=[" + clazz + "]" + ":pri=[" + levelName + "]"); try { Class customLevel = Loader.loadClass(clazz); // get a ref to the specified class' static method // toLevel(String, org.apache.log4j.Level) Class[] paramTypes = new Class[] {String.class, org.apache.log4j.Level.class}; java.lang.reflect.Method toLevelMethod = customLevel.getMethod("toLevel", paramTypes); // now call the toLevel method, passing level string + default Object[] params = new Object[] {levelName, defaultValue}; Object o = toLevelMethod.invoke(null, params); result = (Level) o; } catch (ClassNotFoundException e) { LogLog.warn("custom level class [" + clazz + "] not found."); } catch (NoSuchMethodException e) { LogLog.warn( "custom level class [" + clazz + "]" + " does not have a constructor which takes one string parameter", e); } catch (java.lang.reflect.InvocationTargetException e) { LogLog.warn("custom level class [" + clazz + "]" + " could not be instantiated", e); } catch (ClassCastException e) { LogLog.warn("class [" + clazz + "] is not a subclass of org.apache.log4j.Level", e); } catch (IllegalAccessException e) { LogLog.warn("class [" + clazz + "] cannot be instantiated due to access restrictions", e); } catch (Exception e) { LogLog.warn("class [" + clazz + "], level [" + levelName + "] conversion failed.", e); } return result; }
/* */ protected int extractPrecisionOption() /* */ { /* 113 */ String opt = extractOption(); /* 114 */ int r = 0; /* 115 */ if (opt != null) { /* */ try { /* 117 */ r = Integer.parseInt(opt); /* 118 */ if (r <= 0) { /* 119 */ LogLog.error("Precision option (" + opt + ") isn't a positive integer."); /* */ /* 121 */ r = 0; /* */ } /* */ } /* */ catch (NumberFormatException e) { /* 125 */ LogLog.error("Category option \"" + opt + "\" not a decimal integer.", e); /* */ } /* */ } /* 128 */ return r; /* */ }
public String convert(LoggingEvent event) { date.setTime(event.timeStamp); String converted = null; try { converted = df.format(date); } catch (Exception ex) { LogLog.error("Error occured while converting date.", ex); } return converted; }
/* */ public String convert(LoggingEvent event) /* */ { /* 441 */ this.date.setTime(event.timeStamp); /* 442 */ String converted = null; /* */ try { /* 444 */ converted = this.df.format(this.date); /* */ } /* */ catch (Exception ex) { /* 447 */ LogLog.error("Error occured while converting date.", ex); /* */ } /* 449 */ return converted; /* */ }
/** * Find the value corresponding to <code>key</code> in <code>props</code>. Then perform variable * substitution on the found value. */ public static String findAndSubst(String key, Properties props) { String value = props.getProperty(key); if (value == null) return null; try { return substVars(value, props); } catch (IllegalArgumentException e) { LogLog.error("Bad option value [" + value + "].", e); return value; } }
/** * Configure log4j given a URL. * * <p>The url must point to a file or resource which will be interpreted by a new instance of a * log4j configurator. * * <p>All configurations steps are taken on the <code>hierarchy</code> passed as a parameter. * * <p> * * @param url The location of the configuration file or resource. * @param clazz The classname, of the log4j configurator which will parse the file or resource at * <code>url</code>. This must be a subclass of {@link Configurator}, or null. If this value * is null then a default configurator of {@link PropertyConfigurator} is used, unless the * filename pointed to by <code>url</code> ends in '.xml', in which case {@link * org.apache.log4j.xml.DOMConfigurator} is used. * @param hierarchy The {@link org.apache.log4j.Hierarchy} to act on. * @since 1.1.4 */ public static void selectAndConfigure(URL url, String clazz, LoggerRepository hierarchy) { Configurator configurator = null; String filename = url.getFile(); if (clazz == null && filename != null && filename.endsWith(".xml")) { clazz = "org.apache.log4j.xml.DOMConfigurator"; } if (clazz != null) { LogLog.debug("Preferred configurator class: " + clazz); configurator = (Configurator) instantiateByClassName(clazz, Configurator.class, null); if (configurator == null) { LogLog.error("Could not instantiate configurator [" + clazz + "]."); return; } } else { configurator = new PropertyConfigurator(); } configurator.doConfigure(url, hierarchy); }
public static int toInt(String value, int dEfault) { if (value != null) { String s = value.trim(); try { return Integer.valueOf(s).intValue(); } catch (NumberFormatException e) { LogLog.error("[" + s + "] is not in proper int form."); e.printStackTrace(); } } return dEfault; }
public static Object instantiateByKey( Properties props, String key, Class superClass, Object defaultValue) { // Get the value of the property in string form String className = findAndSubst(key, props); if (className == null) { LogLog.error("Could not find value for key " + key); return defaultValue; } // Trim className to avoid trailing spaces that cause problems. return OptionConverter.instantiateByClassName(className.trim(), superClass, defaultValue); }
/** * This method will search for <code>resource</code> in different places. The search order is as * follows: * * <ol> * <p> * <li>Search for <code>resource</code> using the thread context class loader under Java2. If * that fails, search for <code>resource</code> using the class loader that loaded this * class (<code>Loader</code>). Under JDK 1.1, only the the class loader that loaded this * class (<code>Loader</code>) is used. * <p> * <li>Try one last time with <code>ClassLoader.getSystemResource(resource)</code>, that is is * using the system class loader in JDK 1.2 and virtual machine's built-in class loader in * JDK 1.1. * </ol> */ public static URL getResource(String resource) { ClassLoader classLoader = null; URL url = null; try { if (!java1) { classLoader = getTCL(); if (classLoader != null) { LogLog.debug( "Trying to find [" + resource + "] using context classloader " + classLoader + "."); url = classLoader.getResource(resource); if (url != null) { return url; } } } // We could not find resource. Ler us now try with the // classloader that loaded this class. classLoader = Loader.class.getClassLoader(); if (classLoader != null) { LogLog.debug("Trying to find [" + resource + "] using " + classLoader + " class loader."); url = classLoader.getResource(resource); if (url != null) { return url; } } } catch (Throwable t) { LogLog.warn(TSTR, t); } // Last ditch attempt: get the resource from the class path. It // may be the case that clazz was loaded by the Extentsion class // loader which the parent of the system class loader. Hence the // code below. LogLog.debug("Trying to find [" + resource + "] using ClassLoader.getSystemResource()."); return ClassLoader.getSystemResource(resource); }
public SyslogWriter(String syslogHost) { syslogHost = syslogHost; if (syslogHost == null) { throw new NullPointerException("syslogHost"); } String host = syslogHost; int urlPort = -1; if ((host.indexOf("[") != -1) || (host.indexOf(':') == host.lastIndexOf(':'))) { try { URL url = new URL("http://" + host); if (url.getHost() != null) { host = url.getHost(); if ((host.startsWith("[")) && (host.charAt(host.length() - 1) == ']')) { host = host.substring(1, host.length() - 1); } urlPort = url.getPort(); } } catch (MalformedURLException e) { LogLog.error("Malformed URL: will attempt to interpret as InetAddress.", e); } } if (urlPort == -1) { urlPort = 514; } this.port = urlPort; try { this.address = InetAddress.getByName(host); } catch (UnknownHostException e) { LogLog.error("Could not find " + host + ". All logging will FAIL.", e); } try { this.ds = new DatagramSocket(); } catch (SocketException e) { e.printStackTrace(); LogLog.error( "Could not instantiate DatagramSocket to " + host + ". All logging will FAIL.", e); } }
protected void checkAndConfigure() { boolean fileExists; try { fileExists = file.exists(); } catch (SecurityException e) { LogLog.warn("Was not allowed to read check file existance, file:[" + filename + "]."); interrupted = true; // there is no point in continuing return; } if (fileExists) { long l = file.lastModified(); // this can also throw a SecurityException if (l > lastModif) { // however, if we reached this point this lastModif = l; // is very unlikely. doOnChange(); warnedAlready = false; } } else { if (!warnedAlready) { LogLog.debug("[" + filename + "] does not exist."); warnedAlready = true; } } }
void dump() { LogLog.debug("min=" + min + ", max=" + max + ", leftAlign=" + leftAlign); }
/* */ public PatternConverter parse() /* */ { /* 134 */ this.i = 0; /* 135 */ while (this.i < this.patternLength) { /* 136 */ char c = this.pattern.charAt(this.i++); /* 137 */ switch (this.state) /* */ { /* */ case 0: /* 140 */ if (this.i == this.patternLength) { /* 141 */ this.currentLiteral.append(c); /* */ } /* 144 */ else if (c == '%') /* */ { /* 146 */ switch (this.pattern.charAt(this.i)) { /* */ case '%': /* 148 */ this.currentLiteral.append(c); /* 149 */ this.i += 1; /* 150 */ break; /* */ case 'n': /* 152 */ this.currentLiteral.append(Layout.LINE_SEP); /* 153 */ this.i += 1; /* 154 */ break; /* */ default: /* 156 */ if (this.currentLiteral.length() != 0) { /* 157 */ addToList(new LiteralPatternConverter(this.currentLiteral.toString())); /* */ } /* */ /* 162 */ this.currentLiteral.setLength(0); /* 163 */ this.currentLiteral.append(c); /* 164 */ this.state = 1; /* 165 */ this.formattingInfo.reset(); break; /* */ } /* */ } /* */ else { /* 169 */ this.currentLiteral.append(c); /* */ } /* 171 */ break; /* */ case 1: /* 173 */ this.currentLiteral.append(c); /* 174 */ switch (c) { /* */ case '-': /* 176 */ this.formattingInfo.leftAlign = true; /* 177 */ break; /* */ case '.': /* 179 */ this.state = 3; /* 180 */ break; /* */ default: /* 182 */ if ((c >= '0') && (c <= '9')) { /* 183 */ this.formattingInfo.min = (c - '0'); /* 184 */ this.state = 4; /* */ } /* */ else { /* 187 */ finalizeConverter(c); /* */ } /* */ } /* 189 */ break; /* */ case 4: /* 191 */ this.currentLiteral.append(c); /* 192 */ if ((c >= '0') && (c <= '9')) /* 193 */ this.formattingInfo.min = (this.formattingInfo.min * 10 + (c - '0')); /* 194 */ else if (c == '.') /* 195 */ this.state = 3; /* */ else { /* 197 */ finalizeConverter(c); /* */ } /* 199 */ break; /* */ case 3: /* 201 */ this.currentLiteral.append(c); /* 202 */ if ((c >= '0') && (c <= '9')) { /* 203 */ this.formattingInfo.max = (c - '0'); /* 204 */ this.state = 5; /* */ } /* */ else { /* 207 */ LogLog.error( "Error occured in position " + this.i + ".\n Was expecting digit, instead got char \"" + c + "\"."); /* */ /* 209 */ this.state = 0; /* */ } /* 211 */ break; /* */ case 5: /* 213 */ this.currentLiteral.append(c); /* 214 */ if ((c >= '0') && (c <= '9')) { /* 215 */ this.formattingInfo.max = (this.formattingInfo.max * 10 + (c - '0')); /* */ } else { /* 217 */ finalizeConverter(c); /* 218 */ this.state = 0; /* */ } /* */ case 2: /* */ } /* */ } /* 223 */ if (this.currentLiteral.length() != 0) { /* 224 */ addToList(new LiteralPatternConverter(this.currentLiteral.toString())); /* */ } /* */ /* 227 */ return this.head; /* */ }
public PatternConverter parse() { char c; i = 0; while (i < patternLength) { c = pattern.charAt(i++); switch (state) { case LITERAL_STATE: // In literal state, the last char is always a literal. if (i == patternLength) { currentLiteral.append(c); continue; } if (c == ESCAPE_CHAR) { // peek at the next char. switch (pattern.charAt(i)) { case ESCAPE_CHAR: currentLiteral.append(c); i++; // move pointer break; case 'n': currentLiteral.append(Layout.LINE_SEP); i++; // move pointer break; default: if (currentLiteral.length() != 0) { addToList(new LiteralPatternConverter(currentLiteral.toString())); // LogLog.debug("Parsed LITERAL converter: \"" // +currentLiteral+"\"."); } currentLiteral.setLength(0); currentLiteral.append(c); // append % state = CONVERTER_STATE; formattingInfo.reset(); } } else { currentLiteral.append(c); } break; case CONVERTER_STATE: currentLiteral.append(c); switch (c) { case '-': formattingInfo.leftAlign = true; break; case '.': state = DOT_STATE; break; default: if (c >= '0' && c <= '9') { formattingInfo.min = c - '0'; state = MIN_STATE; } else finalizeConverter(c); } // switch break; case MIN_STATE: currentLiteral.append(c); if (c >= '0' && c <= '9') formattingInfo.min = formattingInfo.min * 10 + (c - '0'); else if (c == '.') state = DOT_STATE; else { finalizeConverter(c); } break; case DOT_STATE: currentLiteral.append(c); if (c >= '0' && c <= '9') { formattingInfo.max = c - '0'; state = MAX_STATE; } else { LogLog.error( "Error occured in position " + i + ".\n Was expecting digit, instead got char \"" + c + "\"."); state = LITERAL_STATE; } break; case MAX_STATE: currentLiteral.append(c); if (c >= '0' && c <= '9') formattingInfo.max = formattingInfo.max * 10 + (c - '0'); else { finalizeConverter(c); state = LITERAL_STATE; } break; } // switch } // while if (currentLiteral.length() != 0) { addToList(new LiteralPatternConverter(currentLiteral.toString())); // LogLog.debug("Parsed LITERAL converter: \""+currentLiteral+"\"."); } return head; }
protected void finalizeConverter(char c) { PatternConverter pc = null; switch (c) { case 'c': pc = new CategoryPatternConverter(formattingInfo, extractPrecisionOption()); // LogLog.debug("CATEGORY converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'C': pc = new ClassNamePatternConverter(formattingInfo, extractPrecisionOption()); // LogLog.debug("CLASS_NAME converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'd': String dateFormatStr = AbsoluteTimeDateFormat.ISO8601_DATE_FORMAT; IDateFormat df; String dOpt = extractOption(); if (dOpt != null) dateFormatStr = dOpt; if (dateFormatStr.equalsIgnoreCase(AbsoluteTimeDateFormat.ISO8601_DATE_FORMAT)) df = new ISO8601DateFormat(); else if (dateFormatStr.equalsIgnoreCase(AbsoluteTimeDateFormat.ABS_TIME_DATE_FORMAT)) df = new AbsoluteTimeDateFormat(); else if (dateFormatStr.equalsIgnoreCase(AbsoluteTimeDateFormat.DATE_AND_TIME_DATE_FORMAT)) df = new DateTimeDateFormat(); else { try { df = new PatternDateFormat(dateFormatStr); } catch (IllegalArgumentException e) { LogLog.error("Could not instantiate SimpleDateFormat with " + dateFormatStr, e); df = new ISO8601DateFormat(); } } pc = new DatePatternConverter(formattingInfo, df); // LogLog.debug("DATE converter {"+dateFormatStr+"}."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'F': pc = new LocationPatternConverter(formattingInfo, FILE_LOCATION_CONVERTER); // LogLog.debug("File name converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'l': pc = new LocationPatternConverter(formattingInfo, FULL_LOCATION_CONVERTER); // LogLog.debug("Location converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'L': pc = new LocationPatternConverter(formattingInfo, LINE_LOCATION_CONVERTER); // LogLog.debug("LINE NUMBER converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'm': pc = new BasicPatternConverter(formattingInfo, MESSAGE_CONVERTER); // LogLog.debug("MESSAGE converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'M': pc = new LocationPatternConverter(formattingInfo, METHOD_LOCATION_CONVERTER); // LogLog.debug("METHOD converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'p': pc = new BasicPatternConverter(formattingInfo, LEVEL_CONVERTER); // LogLog.debug("LEVEL converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 'r': pc = new BasicPatternConverter(formattingInfo, RELATIVE_TIME_CONVERTER); // LogLog.debug("RELATIVE time converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; case 't': pc = new BasicPatternConverter(formattingInfo, THREAD_CONVERTER); // LogLog.debug("THREAD converter."); // formattingInfo.dump(); currentLiteral.setLength(0); break; /*case 'u': if(i < patternLength) { char cNext = pattern.charAt(i); if(cNext >= '0' && cNext <= '9') { pc = new UserFieldPatternConverter(formattingInfo, cNext - '0'); LogLog.debug("USER converter ["+cNext+"]."); formattingInfo.dump(); currentLiteral.setLength(0); i++; } else LogLog.error("Unexpected char" +cNext+" at position "+i); } break;*/ case 'x': pc = new BasicPatternConverter(formattingInfo, NDC_CONVERTER); // LogLog.debug("NDC converter."); currentLiteral.setLength(0); break; case 'X': String xOpt = extractOption(); pc = new MDCPatternConverter(formattingInfo, xOpt); currentLiteral.setLength(0); break; default: LogLog.error("Unexpected char [" + c + "] at position " + i + " in conversion patterrn."); pc = new LiteralPatternConverter(currentLiteral.toString()); currentLiteral.setLength(0); } addConverter(pc); }
/* */ protected void finalizeConverter(char c) /* */ { /* 232 */ PatternConverter pc = null; /* 233 */ switch (c) { /* */ case 'c': /* 235 */ pc = new CategoryPatternConverter(this.formattingInfo, extractPrecisionOption()); /* */ /* 239 */ this.currentLiteral.setLength(0); /* 240 */ break; /* */ case 'C': /* 242 */ pc = new ClassNamePatternConverter(this.formattingInfo, extractPrecisionOption()); /* */ /* 246 */ this.currentLiteral.setLength(0); /* 247 */ break; /* */ case 'd': /* 249 */ String dateFormatStr = "ISO8601"; /* */ /* 251 */ String dOpt = extractOption(); /* 252 */ if (dOpt != null) /* 253 */ dateFormatStr = dOpt; /* */ DateFormat df; /* 255 */ if (dateFormatStr.equalsIgnoreCase("ISO8601")) /* */ { /* 257 */ df = new ISO8601DateFormat(); /* 258 */ } else if (dateFormatStr.equalsIgnoreCase("ABSOLUTE")) /* */ { /* 260 */ df = new AbsoluteTimeDateFormat(); /* 261 */ } else if (dateFormatStr.equalsIgnoreCase("DATE")) /* */ { /* 263 */ df = new DateTimeDateFormat(); /* */ } /* */ else try { /* 266 */ df = new SimpleDateFormat(dateFormatStr); /* */ } /* */ catch (IllegalArgumentException e) { /* 269 */ LogLog.error( "Could not instantiate SimpleDateFormat with " + dateFormatStr, e); /* */ /* 271 */ df = (DateFormat) OptionConverter.instantiateByClassName( "org.apache.log4j.helpers.ISO8601DateFormat", DateFormat.class, null); /* */ } /* */ /* */ /* 276 */ pc = new DatePatternConverter(this.formattingInfo, df); /* */ /* 279 */ this.currentLiteral.setLength(0); /* 280 */ break; /* */ case 'F': /* 282 */ pc = new LocationPatternConverter(this.formattingInfo, 1004); /* */ /* 286 */ this.currentLiteral.setLength(0); /* 287 */ break; /* */ case 'l': /* 289 */ pc = new LocationPatternConverter(this.formattingInfo, 1000); /* */ /* 293 */ this.currentLiteral.setLength(0); /* 294 */ break; /* */ case 'L': /* 296 */ pc = new LocationPatternConverter(this.formattingInfo, 1003); /* */ /* 300 */ this.currentLiteral.setLength(0); /* 301 */ break; /* */ case 'm': /* 303 */ pc = new BasicPatternConverter(this.formattingInfo, 2004); /* */ /* 306 */ this.currentLiteral.setLength(0); /* 307 */ break; /* */ case 'M': /* 309 */ pc = new LocationPatternConverter(this.formattingInfo, 1001); /* */ /* 313 */ this.currentLiteral.setLength(0); /* 314 */ break; /* */ case 'p': /* 316 */ pc = new BasicPatternConverter(this.formattingInfo, 2002); /* */ /* 319 */ this.currentLiteral.setLength(0); /* 320 */ break; /* */ case 'r': /* 322 */ pc = new BasicPatternConverter(this.formattingInfo, 2000); /* */ /* 326 */ this.currentLiteral.setLength(0); /* 327 */ break; /* */ case 't': /* 329 */ pc = new BasicPatternConverter(this.formattingInfo, 2001); /* */ /* 332 */ this.currentLiteral.setLength(0); /* 333 */ break; /* */ case 'x': /* 349 */ pc = new BasicPatternConverter(this.formattingInfo, 2003); /* */ /* 351 */ this.currentLiteral.setLength(0); /* 352 */ break; /* */ case 'X': /* 354 */ String xOpt = extractOption(); /* 355 */ pc = new MDCPatternConverter(this.formattingInfo, xOpt); /* 356 */ this.currentLiteral.setLength(0); /* 357 */ break; /* */ case 'D': /* */ case 'E': /* */ case 'G': /* */ case 'H': /* */ case 'I': /* */ case 'J': /* */ case 'K': /* */ case 'N': /* */ case 'O': /* */ case 'P': /* */ case 'Q': /* */ case 'R': /* */ case 'S': /* */ case 'T': /* */ case 'U': /* */ case 'V': /* */ case 'W': /* */ case 'Y': /* */ case 'Z': /* */ case '[': /* */ case '\\': /* */ case ']': /* */ case '^': /* */ case '_': /* */ case '`': /* */ case 'a': /* */ case 'b': /* */ case 'e': /* */ case 'f': /* */ case 'g': /* */ case 'h': /* */ case 'i': /* */ case 'j': /* */ case 'k': /* */ case 'n': /* */ case 'o': /* */ case 'q': /* */ case 's': /* */ case 'u': /* */ case 'v': /* */ case 'w': /* */ default: /* 359 */ LogLog.error( "Unexpected char [" + c + "] at position " + this.i + " in conversion patterrn."); /* */ /* 361 */ pc = new LiteralPatternConverter(this.currentLiteral.toString()); /* 362 */ this.currentLiteral.setLength(0); /* */ } /* */ /* 365 */ addConverter(pc); /* */ }